How To Track Form Submissions In Google Analytics

Your forms are collecting leads. But do you actually know which ones are working? Learning how to track form submissions in Google Analytics is the difference between guessing and knowing what drives conversions on your site.

GA4’s event-based model changed how form tracking works. Enhanced measurement, Google Tag Manager triggers, gtag.js, thank you page tracking, and the Measurement Protocol all handle it differently. Some methods take five minutes. Others need developer support.

This guide covers every method for setting up form submission tracking in GA4, from the simplest toggle to custom dataLayer configurations. You’ll also learn how to verify your setup, turn form events into key event conversions, and fix the problems that break tracking without warning.

What Is Form Submission Tracking in Google Analytics

Form submission tracking is the process of recording when someone fills out and submits a form on your website, then logging that action as an event inside Google Analytics. Every contact form, signup box, and checkout step generates data. Without tracking, you’re flying blind.

GA4 treats every user interaction as an event. That includes form submissions. There are no “goals” anymore, no destination-based conversions like the old Universal Analytics setup. Just events and parameters.

The shift matters more than people realize. GA4’s event-based data model means a formsubmit event carries specific parameters with it: form ID, form name, form destination URL, and submit button text. You get granular detail on which form was submitted, not just that something happened.

Google Analytics is used by roughly 14.2 million active websites worldwide as of 2025 (GA4.com). And Meetanshi reports that 98.1% of Google Tag Manager users also run Google Analytics alongside it. These two tools work together for form tracking more often than not.

The types of forms you might track vary widely. Lead generation forms, newsletter signups, quote request forms, event registrations, survey submissions. Each one represents a different conversion type, and GA4 lets you track all of them under a single event-based framework.

Here’s what gets captured per form event:

Zuko Analytics benchmarking data shows that only 45% of people who visit a form go on to complete it. The other 55% abandon. That stat alone makes tracking form submissions a baseline requirement, not a nice-to-have.

If you run WordPress forms, the tracking setup gets a bit more specific depending on your form plugin. But the core GA4 mechanics stay the same regardless of platform.

How Google Analytics 4 Handles Form Events

GA4 runs on events. Period. Every click, scroll, video play, and form interaction gets recorded as an event with attached parameters. This replaced Universal Analytics’ session-based model when Google officially sunset UA in July 2023.

Two event categories matter for form tracking:

Enhanced measurement events are the automatic ones. GA4 ships with built-in tracking for things like page views, scrolls, outbound clicks, site search, file downloads, and yes, form interactions. You toggle them on in your data stream settings without touching code.

Custom events are the ones you build yourself, usually through Google Tag Manager or by calling gtag.js directly. These give you full control over what triggers the event, what parameters get sent, and how the data shows up in your reports.

GA4’s enhanced measurement includes two form-specific events:

• formstart: Fires once per session when a user first interacts with a form field
• formsubmit: Fires when the form is submitted (in theory)

The gap between formstart and formsubmit tells you something. It shows how many people begin filling out your form but never finish. That’s your form abandonment rate in raw numbers.

But there’s a catch. Analytics Mania’s Julius Fedorovicius, one of the most cited GA4 experts, recommends against using enhanced measurement for form tracking because of its unreliability. He notes it can track unsuccessful submissions and completely miss AJAX-based forms.

Data Marketing School reports similar findings. Their recommendation is to disable GA4’s enhanced measurement entirely on client projects due to lack of flexibility and potential data quality issues.

A Forrester Consulting study found that 63% of analytics decision-makers rank analytics among their top five marketing priorities. Getting form data right matters, because bad data leads to bad decisions. And GA4’s automatic form tracking frequently delivers bad data.

The Event Parameter Structure

Every GA4 form event carries parameters. Think of them as metadata attached to the event.

The defaults include formid, formname, formdestination, and formsubmittext. But to actually see these in your standard GA4 reports, you need to register them as custom dimensions. Otherwise, the data exists but stays buried.

GA4 gives standard properties a quota of 50 custom dimensions. Each form parameter you register eats into that quota. If you’re also tracking e-commerce events, video engagement, and other custom parameters, that limit gets tight fast.

Tracking Form Submissions with Enhanced Measurement

Enhanced measurement is the path of least resistance. No code, no Google Tag Manager, no developer involvement. You flip a switch in GA4’s admin panel and it starts collecting form interaction data automatically.

To set it up: go to Admin, then Data Streams, select your web stream, and toggle on Enhanced Measurement. Inside that panel, make sure Form Interactions is specifically enabled. It’s not always on by default.

GA4 then listens for standard HTML form submit events in the browser. When a visitor clicks a submit button on a traditional <form> element, GA4 captures it.

Simple enough. Until it isn’t.

When Enhanced Measurement Fails

I’ve seen this trip up more people than almost any other GA4 feature. Enhanced measurement form tracking sounds perfect in the documentation, then falls apart on real websites.

AJAX forms: Most modern forms submit data asynchronously without reloading the page. GA4’s built-in listener doesn’t reliably catch these. If your site uses React, Vue.js, or Angular, your forms almost certainly use AJAX. The enhanced measurement formsubmit event just won’t fire.

Single-page applications: SPAs built with JavaScript frameworks handle navigation through history changes, not traditional page loads. Enhanced measurement struggles with this architecture across the board, not just for forms.

MeasureSchool’s analysis confirms that enhanced measurement may even fire on unsuccessful submissions, like when a required field is left blank and form validation kicks in. That pollutes your data with false positives.

Iframe-embedded forms: If you’re embedding a Typeform, HubSpot form, or JotForm widget, those live inside iframes. Cross-origin restrictions block GA4’s enhanced measurement from detecting anything inside them.

SQMagazine reports that over 60% of GA4 implementations struggle with configuration complexity and data discrepancies. Enhanced measurement’s form tracking is one of the biggest contributors to that number.

The bottom line: enhanced measurement works for basic HTML forms on simple sites. For anything else, you need Google Tag Manager or custom code.

Tracking Form Submissions Through Google Tag Manager

Google Tag Manager is the tool most analytics professionals reach for when enhanced measurement doesn’t cut it. And for form tracking specifically, it almost never cuts it.

GTM sits between your website and GA4. It watches for specific events (triggers), then fires tags that send data to your analytics property. For forms, you configure a trigger that detects submissions, then pair it with a GA4 event tag.

SimilarTech data shows GTM adoption grew 7.1% between 2023 and 2025. The tag management tool is used on 65% of e-commerce websites globally, according to Statista. So if you’re not already running it, you’re in the minority.

Setting Up a Form Submission Trigger

Inside GTM, create a new trigger and select “Form Submission” as the trigger type. GTM listens for the browser’s native form submit event.

Filter the trigger so it only fires on the forms you actually care about. Use Form ID, Form Classes, or the page URL as your filter condition. Without filtering, every form on your site (including search bars) will trigger the event.

Then create a GA4 Event tag. Set the event name to something descriptive like “contactformsubmit” or “quoterequestsubmit.” Connect it to your Measurement ID. Link the trigger you just made.

Test it in GTM’s Preview and Debug mode before publishing. Submit a test form. Watch for the trigger to fire and the tag to execute. If both show green checkmarks, publish the container.

Using the Element Visibility Trigger as a Fallback

Some forms don’t reload the page or redirect anywhere after submission. Instead, they show a success message right on the same page. Think “Thank you! We’ll be in touch.” appearing where the form used to be.

GTM’s Element Visibility trigger catches this. You point it at the CSS selector of the confirmation message element. When that element appears in the viewport, the trigger fires.

This works well for AJAX forms and multi-step forms that display a completion message without changing the URL. It’s one of the most reliable methods for forms built with popular WordPress contact form plugins like WPForms, Gravity Forms, or Contact Form 7.

Custom Event Push via dataLayer

This is the most reliable method. Full stop.

Your form’s JavaScript fires a dataLayer.push() call the moment a submission succeeds. It looks like this:

dataLayer.push({'event': 'formsubmission', 'formname': 'contact', 'formlocation': '/pricing/'});

In GTM, you create a Custom Event trigger that listens for the “formsubmission” event name from the dataLayer. Then attach your GA4 Event tag to it.

The reason this beats everything else: the event only fires when your code explicitly says it should. No false positives from search bars. No missed AJAX submissions. No guessing.

Zuko Analytics data shows the average form abandonment time is 1 minute and 43 seconds. If your tracking fires on formstart but misses the actual submission because of a technical gap, you’ll think your abandonment rate is worse than it really is. Accurate dataLayer-based tracking prevents that.

Tracking Form Submissions with gtag.js Directly

Not every site runs Google Tag Manager. Some are simple single-page setups. Others have development teams that prefer keeping everything in code. For those situations, gtag.js handles form tracking directly.

The gtag.js library is Google’s JavaScript tagging framework. If you’ve installed GA4 using the Global Site Tag snippet (instead of GTM), you already have it loaded.

Adding the Event Call

Inside your form’s submit handler, add a gtag event call:

gtag('event', 'formsubmit', {'formname': 'contact', 'formid': 'main-contact'});

That sends a custom event with parameters directly to your GA4 property. No middleman, no tag management layer.

The challenge here is timing. When a form submits, the browser often navigates to a new page immediately. Your gtag event call might not finish sending before the page unloads. The data gets lost.

Fix: Use the transporttype: 'beacon' parameter. The browser’s Beacon API sends data asynchronously even during page unload. It looks like:

gtag('event', 'formsubmit', {'formname': 'contact', 'transporttype': 'beacon'});

This approach works best for sites with one or two forms. A landing page with a single lead generation form, for example. Took me a while to realize that for anything more complex, GTM saves you time in the long run. But for straightforward setups, gtag.js does the job cleanly.

When gtag.js Makes More Sense Than GTM

If your site has fewer than three forms and a developer already manages the codebase, adding a gtag call is faster than configuring GTM triggers.

Also worth considering if you want to avoid loading another third-party script. GTM adds weight to your page. For performance-sensitive mobile forms or minimalist landing pages, one less script matters.

Unbounce’s analysis of 41,000 landing pages found that 81% of people abandon forms after starting them. Page speed plays a role in that. Every millisecond counts, and cutting a script (even GTM) can help.

Tracking Forms That Redirect to a Thank You Page

This is probably the oldest and simplest form tracking method. And honestly, it still works in a lot of cases.

The logic is straightforward: your form redirects the user to a unique thank you page URL after submission. You tell GA4 to count every visit to that URL as a conversion event. Done.

Setting It Up in GA4

Go to Admin, then Events, and create a new event. Name it something like “formsubmissionthankyou.” Set the condition to match when eventname equals “pageview” AND pagelocation contains your thank you page path (like “/thank-you/” or “/confirmation/”).

That’s it. Every time someone lands on that page, GA4 records the event.

In GTM, the approach is similar. Create a Pageview trigger filtered to fire only when the Page URL matches your thank you page. Attach a GA4 Event tag to it.

The Risks

Thank you page tracking has blind spots that catch people off guard.

Direct URL visits: Anyone who bookmarks the thank you page, or a bot that crawls it, registers as a form submission. Your conversion numbers get inflated. To counter this, you can add referrer checks. Only count the event if the previous page was the actual form page.

No form-specific data: All you know is that someone hit the thank you page. You don’t know which form they submitted (if multiple forms share the same confirmation page), what they entered, or how long it took them.

For sites with a single contact us page and one form, this method is fine. But the moment you add more forms or need richer data, you’ll outgrow it quickly.

Insiteful research shows that 67% of site visitors will abandon a form permanently if they hit any complications. If you’re only tracking the thank you page, you’ll never see those abandoned attempts or understand what went wrong.

The Manifest survey data backs this up: security concerns cause 29% of form abandonments, and form length causes another 27%. Thank you page tracking tells you nothing about why people drop off. It only tells you who made it through.

For deeper insight into why users leave forms incomplete, pairing your tracking setup with strategies for increasing form conversions is the logical next step.

Tracking Third-Party and Embedded Forms

Not every form on your site lives on your site. Typeform embeds, HubSpot popups, JotForm widgets, Google Forms, Calendly booking pages. All of these run inside iframes or redirect users to external domains.

Standard Google Tag Manager triggers can’t reach inside iframes. Cross-origin browser restrictions block it. Your carefully configured form submission trigger fires on nothing because it literally cannot see the form.

Three workarounds exist, and each fits a different scenario.

The Redirect Method

How it works: Configure the third-party form tool to redirect users back to a thank you page on your domain after submission. Then track that page as a conversion event in GA4, just like any other thank you page setup.

Typeform, JotForm, and Google Forms all support custom redirect URLs on completion. This is the simplest option if you don’t mind the extra page load.

The downside is that you lose the seamless embedded experience. Users leave your page, hit the external form, then bounce back. For popup forms or inline widgets, that transition feels clunky.

The Webhook and Measurement Protocol Method

Most third-party form platforms support webhooks. When someone submits a form, the platform sends a server-side HTTP request to a URL you specify.

You can route that webhook to a server that then sends the event data to GA4 using the Measurement Protocol. The Measurement Protocol accepts HTTP POST requests and writes events directly to your GA4 property, no browser involved.

Google’s documentation confirms the Measurement Protocol sends events directly to GA4 servers via HTTP requests, augmenting client-side collection methods like gtag and GTM.

The tricky part: you need a valid clientid that matches an existing user session. Without it, GA4 creates an orphaned event with no user context. Capturing the clientid from the page before the user interacts with the embedded form (and passing it along with the webhook) solves this, but requires developer involvement.

Platform-Specific Solutions

HubSpot stands out here. Its embedded forms fire a global JavaScript event that GTM can listen for without needing iframe access. You set up a Custom Event trigger in GTM for the HubSpot form callback, and it works reliably.

Calendly takes a different route, sending postMessage events from the iframe to the parent page. GTM can pick these up with a custom HTML tag that listens for the message event and pushes to the dataLayer.

If your site collects data through various web forms across multiple platforms, documenting which method you’re using for each form saves headaches down the road. Especially when someone new inherits the analytics setup.

Verifying Form Tracking Is Working

Setting up form tracking and assuming it works is a recipe for bad data. Standard GA4 reports can take 24 to 48 hours to process, according to Google’s own documentation. If something’s broken, you could lose two full days of conversion data before you even notice.

Test everything before you trust it.

GA4 Realtime Report

Open your GA4 property, go to Reports, then Realtime. Submit a test form on your site. Within a minute or two, you should see your custom event (like “contactformsubmit”) appear in the event count.

Realtime shows aggregated data from all active users. It won’t isolate your specific test. But if your event name pops up right after you submit, that’s a good first signal.

GA4 DebugView

DebugView is the real testing tool. It isolates events from a single device and shows every parameter attached to each event.

Three ways to activate it:

• Install the Google Analytics Debugger Chrome extension and toggle it on
• Open GTM Preview mode (automatically enables debug mode)
• Add debugmode: true to your GA4 configuration tag

Once active, go to Admin, then DebugView. Submit your form. You should see the event appear in the seconds stream with all its parameters listed.

Analytics Mania notes that the most common DebugView issue is “no data showing up,” which usually means the debug flag isn’t being sent correctly, not that tracking itself is broken.

Cross-Checking Against Known Submissions

This step gets skipped constantly, and it shouldn’t.

Compare your GA4 event count to your actual submission records. If your CRM logged 47 form submissions last week and GA4 shows 52, you’ve got duplicates. If GA4 shows 31, your tracking is missing events.

Zuko Analytics data shows that desktop form completion rates sit at 47% compared to 42% on mobile. If your GA4 data shows the opposite pattern, something is likely misconfigured for one device type.

Turning Form Submissions into Conversions in GA4

Tracking form submissions as events is step one. Turning those events into conversions (now called “key events” in GA4) is where the business value actually shows up in your reports.

Google renamed “conversions” to “key events” in March 2024. The functionality is identical. The term changed to align GA4 reporting with Google Ads, where imported key events still appear as conversions.

Marking an Event as a Key Event

Go to Admin, then Events. Find your form submission event in the list. Toggle the “Mark as key event” switch.

That’s it. GA4 now treats every instance of that event as a key event and surfaces it in your conversion reports, session key event rate, and user key event rate metrics.

According to newage. agency, key events in 2024-2025 are automatically available for import into Google Ads without manual linking. That’s a significant improvement over the old workflow.

Passing Key Events to Google Ads

If you run paid campaigns, this is where form tracking pays for itself. Once your form submission key event exists in GA4, you can create a corresponding conversion in Google Ads based on that event.

Google Ads then uses this conversion data for Smart Bidding strategies like Target CPA and Maximize Conversions. Your ad spend optimizes toward users who are actually likely to fill out your forms, not just click through.

SQMagazine reports that leading firms using GA4 for actionable insights see a 34% marketing ROI improvement tied directly to better attribution and audience targeting. Form conversion data is a huge part of that.

Assigning Different Values to Different Forms

Not all form submissions carry the same weight.

A lead generation form on a pricing page is worth more than a general inquiry from a blog sidebar. GA4 lets you assign event values to reflect this.

When configuring your GA4 Event tag in GTM, add a value parameter. Set it based on the form type or page location. A quote request might carry a value of 100 while a newsletter signup gets 10.

This feeds directly into ROI calculations in both GA4 and Google Ads. Your reports stop treating all form submissions equally, and your bidding strategies get smarter.

Common Form Tracking Problems and Fixes

Even a well-planned tracking setup breaks. Forms change, developers push code updates, plugins get swapped out. The tracking that worked last month can silently fail today.

SQMagazine data shows that only 37% of businesses trust their analytics data enough to use it for major strategic decisions. Bad form tracking is one of the reasons that number is so low.

Duplicate Events

The symptom: GA4 shows twice as many form submissions as your CRM or email notifications.

Usually caused by running enhanced measurement’s form tracking alongside a custom GTM setup. Both fire on the same submission, and GA4 counts both. Disable the enhanced measurement form interaction event if you’ve built custom tracking in GTM.

Double-check for multiple GA4 tags firing on the same page, too. Happens more often than you’d think, especially on WordPress sites with overlapping analytics plugins.

AJAX Forms Not Triggering

GTM’s built-in Form Submission trigger listens for the browser’s native form submit event. AJAX forms (built with React, Vue.js, or jQuery) bypass that event entirely.

Fix: Use a dataLayer.push() from your form’s success callback, or use GTM’s Element Visibility trigger to detect the success message appearing after submission. Both approaches work independently of how the form actually sends data.

Single-Page Applications

On SPAs, the page URL doesn’t change after form submission. Thank you page tracking won’t work because there is no new page. Enhanced measurement’s form tracking is also unreliable on SPAs, according to Data Marketing School.

The dataLayer approach is the only consistently reliable option here. Your SPA framework fires dataLayer.push() when the form submit promise resolves.

Cross-Domain Tracking Gaps

If your form lives on a different domain than your main site (forms.yourcompany.com vs. yourcompany.com), GA4 creates separate sessions for the same user. Your attribution data breaks.

Configure cross-domain tracking in your GA4 data stream settings. Add both domains so GA4 passes the clientid between them and stitches the sessions together.

Event Parameters Showing as “(not set)”

You set up custom parameters like formname and formlocation. GA4 collects them. But in your reports, they show “(not set).”

Reason: You need to register those parameters as custom dimensions in GA4. Go to Admin, then Custom Definitions, and create a new custom dimension for each parameter. Until you do this, GA4 captures the data but doesn’t make it available in standard reports or explorations.

Remember, GA4 caps standard properties at 50 custom dimensions. Plan carefully.

Ad Blockers and Browser Extensions Preventing Tags from Firing

GWI data from 2025 shows that 29.5% of internet users globally use ad blockers at least sometimes. Among tech-savvy audiences (which is exactly who visits many B2B SaaS sites), that number climbs to 50-60%, per Kissmetrics research.

Ad blockers don’t just block ads. Many block Google Analytics and Google Tag Manager scripts entirely. Your form submission event never fires because the tracking code never loads in the first place.

Server-side tagging through GTM’s server container is the most robust workaround. It moves the tracking logic to your own server, so browser-based blockers can’t intercept it. Analytics Mania reports that server-side tagging adoption grew 47% from 2023 to 2025, largely via GTM.

For teams not ready for server-side GTM, the practical reality is this: accept that a percentage of form submissions will go untracked. Build that margin into your reporting. Compare GA4 numbers against your CRM or email notification counts to understand the gap.

If you’re running GDPR compliant forms, consent mode adds another layer. GA4’s Consent Mode v2 uses machine learning to model conversions from users who declined tracking. It won’t be perfectly accurate, but it fills some of the gap.

FAQ on How To Track Form Submissions In Google Analytics

Does GA4 track form submissions automatically?

Only partially. GA4’s enhanced measurement includes a formsubmit event, but it’s unreliable. It misses AJAX forms, iframe embeds, and single-page applications. Most analytics professionals disable it and build custom tracking through Google Tag Manager instead.

What is the best way to track form submissions in GA4?

A dataLayer.push() event fired from your form’s success callback, captured by a Custom Event trigger in GTM. This method only fires on confirmed submissions, avoids false positives, and works with AJAX forms, SPAs, and standard HTML forms.

How do I track form submissions using Google Tag Manager?

Create a Form Submission trigger in GTM filtered by form ID or CSS class. Pair it with a GA4 Event tag using your Measurement ID. Test in GTM’s Preview mode before publishing. Use Element Visibility triggers as a fallback for AJAX forms.

Can I track embedded Typeform or HubSpot forms in GA4?

Yes, but not with standard GTM triggers. Cross-origin iframe restrictions block them. HubSpot fires a global JavaScript event GTM can capture. Typeform supports redirect URLs to a thank you page on your domain, which GA4 tracks as a page view event.

How do I verify that form tracking is working correctly?

Use GA4 DebugView to see events from your device in real time. Submit a test form and check that the event appears with correct parameters. Cross-reference GA4 event counts against your CRM or email notification records for accuracy.

What is the difference between a key event and a conversion in GA4?

Google renamed “conversions” to key events in March 2024. In GA4 reports, they’re called key events. When imported into Google Ads, they appear as conversions. The functionality is identical. The terminology changed to align both platforms.

Why are my form submission events showing duplicate counts?

You’re likely running enhanced measurement form tracking alongside a custom GTM setup. Both fire on the same submission. Disable the form interaction toggle in enhanced measurement settings if you’ve built your own tracking through Tag Manager.

How do I track forms that redirect to a thank you page?

Create a GA4 event that fires when pagelocation matches your thank you page URL. Set this up in GTM with a pageview trigger filtered to that path. Add referrer checks to prevent direct URL visits from inflating your numbers.

Do ad blockers affect form submission tracking in GA4?

Yes. Ad blockers often block Google Analytics and GTM scripts entirely. Around 29.5% of users run blockers globally. Server-side tagging through GTM’s server container is the most reliable workaround, since it moves tracking off the browser.

Can I assign different values to different form submissions?

Yes. Add a value parameter to your GA4 Event tag in GTM. Set it based on form type or page location. A pricing page quote request might get a value of 100, while a blog newsletter signup gets 10. This feeds directly into ROI reporting.

Conclusion

Knowing how to track form submissions in Google Analytics comes down to picking the right method for your setup. Enhanced measurement works for basic HTML forms. Everything else needs GTM triggers, dataLayer events, or the Measurement Protocol.

Start with one form. Get the event parameter configuration right. Verify it in DebugView. Then mark it as a key event and connect it to Google Ads if you’re running paid campaigns.

The biggest mistake is setting up tracking once and never checking it again. Forms change. Plugins update. Developers push new code. Build a habit of cross-checking your GA4 event counts against your CRM records at least monthly.

Your form design and your tracking setup are equally important. One gets people to submit. The other proves it happened. Skip either one and you’re making decisions without data.

Get both right, and your conversion tracking actually means something.