Most teams spend significant time and budget driving traffic to their forms, but have little visibility into what happens after a visitor lands on the page. Do they fill out the form? Drop off halfway through? Submit and bounce? Without Google Analytics form tracking in place, these questions go unanswered, and optimization becomes guesswork.
This guide walks you through the complete setup process: from connecting Google Analytics to your forms, to configuring events and conversions, to reading the data that actually matters. Whether you're tracking a lead generation form, a demo request, or a multi-step qualification flow, the steps here apply.
By the end, you'll have a working tracking setup that tells you exactly how your forms are performing and where to improve them. No developer required for most of it. Let's get into it.
Step 1: Confirm Your Google Analytics 4 Property Is Ready
Before touching a single tag or trigger, you need to verify your foundation. This sounds obvious, but skipping this step is one of the most common reasons teams spend hours troubleshooting tracking issues that were never going to work in the first place.
First, confirm you're working with a GA4 property, not a legacy Universal Analytics property. Universal Analytics is fully deprecated and no longer processes data. To check, navigate to your Google Analytics account, click Admin in the bottom left, and look at the Property column. A GA4 property will show a Measurement ID in the format G-XXXXXXXXXX. Copy this ID and keep it handy. You'll need it in Step 4.
Next, verify that your GA4 tracking snippet is actually firing on your site. There are two reliable ways to do this:
Google Tag Assistant: Install the Tag Assistant Companion Chrome extension, visit your site, and confirm GA4 is detected and sending hits.
GA4 DebugView: In your GA4 property, navigate to Admin > DebugView. Open your site in a new tab. If the base tag is firing correctly, you'll see live events streaming in DebugView within seconds of page interactions.
If GA4 isn't firing yet, you have two installation options. The recommended approach is Google Tag Manager (covered in Step 2). The alternative is pasting the GA4 configuration snippet directly into the <head> of every page. For most teams, GTM is the better long-term choice, but the direct snippet works fine if your site is simple and you have developer access.
One more thing to check: make sure the GA4 property is connected to the correct website URL. It's surprisingly common for teams to have multiple GA4 properties and accidentally configure tracking for the wrong one.
Success indicator: DebugView in GA4 shows live hits, including page_view events, when you visit your site in a separate browser tab.
Step 2: Install Google Tag Manager on Your Site
Google Tag Manager is the recommended method for setting up Google Analytics form tracking. It keeps all your tracking logic in one centralized place, lets non-developers make updates without touching site code, and comes with a built-in testing environment that makes debugging significantly easier.
If GTM is already installed on your site, skip to the verification step at the end of this section. If not, here's how to get it set up.
Go to tagmanager.google.com and create a new account. Set up a Web container for your domain. GTM will provide two code snippets: one for the <head> and one for the <body> of your pages. Both need to be installed on every page of your site, including the page where your form lives.
If you're using a CMS like WordPress, Webflow, or Shopify, there are native GTM integration options that make this a one-time paste. If you're on a custom-built site, a developer will need to add the snippets to your site template.
One thing worth checking before you proceed: if you're using a modern form builder like Orbit AI, verify whether it has native GTM or GA4 integration built in. Native integrations can eliminate several of the manual steps in this guide and reduce the chance of configuration errors.
A critical flag for teams using embedded forms: if your form lives on a third-party domain or inside an iframe, standard GTM tracking won't capture submissions without additional cross-domain configuration. This is a common scenario with hosted form tools. Check whether your form's domain matches your main site domain. If it doesn't, you'll need a separate GTM container on the form domain or a cross-domain tracking setup. Flag this now rather than discovering the data gap after weeks of missing submissions.
Once GTM is installed, verify it's working using GTM Preview mode. Click the Preview button in the top right of the GTM interface, enter your site URL, and confirm the GTM container loads. You'll see a debug panel at the bottom of your browser showing which tags and triggers are firing.
Success indicator: GTM Preview mode shows your container loading on the page where your form lives, with a Page View event in the event stream.
Step 3: Create a Form Submission Trigger in GTM
Now the real work begins. A trigger tells GTM when to fire a tag. For form tracking, you want the trigger to fire specifically when a visitor successfully submits your form.
In GTM, navigate to Triggers > New and select Form Submission as the trigger type. You'll see two configuration options that are worth understanding before you click save.
Wait for Tags: Enable this option. It ensures the GA4 event tag has time to fire before the browser navigates away from the page after submission. Without this, fast page redirects can cause the tag to fire incompletely, and you'll see missing data in GA4.
Check Validation: Enable this too. It tells GTM to only fire the trigger when the form passes its own validation, meaning the visitor actually completed the required fields. Without this, you'd track every submission attempt, including failed ones where the user hit submit but got an error message.
For the trigger scope, you have two choices. Start with Some Forms rather than All Forms, and add a condition to scope it to your specific form. You can filter by Form ID, Form Classes, or Page URL. Using Page URL is the simplest option if your form only lives on one page. Using Form ID is more precise if you have multiple forms on the same page.
To find your form's ID or class, right-click the form in your browser, select Inspect, and look at the <form> element in the HTML. The id or class attribute is what you'll use in the GTM condition.
Now test it. With GTM Preview mode active, navigate to your form page and submit a test entry. In the GTM debug panel, you should see a Form Submit event appear in the event stream with the trigger you just created listed as firing.
Here's an important pitfall: many modern form builders use AJAX submission, meaning the form submits without a full page reload. Standard GTM Form Submission triggers rely on the browser's native form submit event and may not catch AJAX submissions reliably. If you submit your form and the trigger doesn't fire in Preview mode, this is likely why. In that case, you have two options: use a custom JavaScript trigger that listens for the AJAX completion event, or use an Element Visibility trigger that fires when a thank-you message or confirmation element appears on the page after submission.
Success indicator: GTM Preview shows the Form Submission trigger firing when you complete a test submission, with no extra firings when you land on the page without submitting.
Step 4: Configure a GA4 Event Tag for Form Submissions
With your trigger in place, you now need to tell GTM what to do when that trigger fires. That's where the GA4 Event tag comes in.
In GTM, go to Tags > New and select Google Analytics: GA4 Event as the tag type. You'll need to connect this tag to your GA4 Configuration Tag, which is the tag that holds your Measurement ID (the G-XXXXXXXXXX from Step 1). If you haven't created a GA4 Configuration Tag yet, create one now by adding a new tag of type Google Analytics: GA4 Configuration, entering your Measurement ID, and setting it to fire on All Pages.
For the event name, use generate_lead. This is GA4's officially recommended event name for lead form submissions. Using this specific name matters: GA4 automatically recognizes it as a key event type and surfaces it in built-in reporting without extra configuration. A custom name like form_submit would work technically, but you'd lose the automatic recognition.
Next, add event parameters. These are what allow you to distinguish between multiple forms across your site and understand which specific form drove each submission. Add the following parameters:
form_id: Use the built-in GTM variable {{Form ID}}. This captures the HTML ID attribute of the submitted form automatically.
form_name: Use {{Form Classes}} or create a custom constant variable with a descriptive name like "demo-request-form" or "newsletter-signup". The custom variable approach gives you cleaner, more readable data in GA4.
page_location: Use the built-in GTM variable {{Page URL}}. This tells you which page the form submission came from, which is essential if the same form appears on multiple pages.
Set the trigger to the Form Submission trigger you created in Step 3. Save the tag.
Before publishing, test the full setup in GTM Preview mode. Submit your form and confirm the GA4 Event tag fires with the correct event name and parameters. Then switch to GA4 DebugView and verify the generate_lead event appears there with your custom parameters attached.
Once everything looks correct, click Submit in GTM to publish your container. Changes do not go live until you publish. This is a step that's easy to forget.
Success indicator: GA4 DebugView shows the generate_lead event firing with form_id, form_name, and page_location parameters when you submit a test form.
Step 5: Mark the Event as a Key Event in GA4
Tracking an event is one thing. Telling GA4 that this event represents a meaningful conversion is another. This step is what connects your form tracking to GA4's conversion reporting, Google Ads optimization, and audience building.
In GA4, navigate to Admin > Events. Your generate_lead event will appear in this list once it has fired at least once. If you just tested it using DebugView, it may take up to 24 hours to populate in the standard Events list. If you're impatient, you can proceed with the next steps and come back to toggle this once the event appears.
When you see the event, click the toggle next to Mark as key event. In GA4, key events are the equivalent of what Universal Analytics called Goals. Enabling this toggle tells GA4 to count this event as a conversion in your reports, making it visible in dedicated Key Events reports and available for use in Google Ads campaigns if your accounts are linked.
If you're tracking multiple form types across your site, consider using separate event names for each rather than a single generate_lead event for everything. For example: generate_lead_demo for demo request forms, generate_lead_newsletter for newsletter signups, generate_lead_contact for contact forms. This lets you measure conversion rates independently for each form type and understand which forms are actually driving business value.
After marking the event as a key event, navigate to Reports > Engagement > Key Events to confirm it's appearing in standard reporting. Keep in mind that data here reflects a 24-48 hour processing window, so real-time verification should still happen in DebugView.
Success indicator: Your generate_lead event appears under Key Events in GA4 Admin with the toggle enabled, and it shows up in the Key Events engagement report.
Step 6: Build a Form Performance Report in GA4
Standard GA4 reports won't surface form-specific insights by default. To actually understand how your forms are performing, you need to build a custom report using GA4's Explore feature, which you'll find as a compass icon in the left navigation.
There are two report types worth building: a free-form report for submission volume analysis, and a funnel exploration for conversion rate and drop-off analysis.
Free-Form Report Setup: Create a new Exploration and select the Blank template. Add Event Name and Page Path as your dimensions. Add Event Count and Key Events as your metrics. Then apply a filter to show only rows where Event Name exactly matches generate_lead. This gives you a clean view of form submission volume broken down by page, so you can see which pages are generating the most submissions.
Funnel Exploration Setup: Create a new Exploration and select the Funnel technique. Define Step 1 as a page_view event on your form page (use a Page Path condition to specify the URL). Define Step 2 as your generate_lead event. GA4 will calculate the conversion rate between these two steps and show you the percentage of visitors who viewed the form page and then submitted. This is your form's baseline conversion rate.
The funnel report is particularly powerful for diagnosing problems. If you're seeing strong traffic to your form page but a low step-to-step conversion rate, the issue is with the form itself, not your traffic quality. That's a form design and UX problem worth solving. If you're curious about the specific reasons visitors abandon forms before submitting, our post on why visitors abandon forms covers the most common friction points in detail.
To go deeper, add a segment to your funnel report to break down conversion rates by traffic source. Use Session Source/Medium as your segmentation dimension. This reveals which channels drive visitors who actually complete your forms versus channels that drive volume but low-quality traffic.
For teams using Orbit AI's form builder, the native analytics integration surfaces form-specific performance data directly within the platform, which can complement what you're building in GA4 Explore.
Success indicator: Your Exploration report shows form submission counts, a calculated conversion rate for your form page, and a traffic source breakdown that reveals which channels drive the most form completions.
Step 7: Validate, Monitor, and Act on Your Data
Setup is done. Now comes the part that most teams skip: making sure the data is actually reliable, and building a process to use it.
Start with a full QA pass. Submit your form multiple times across different devices (desktop, mobile) and different browsers (Chrome, Safari, Firefox). After each submission, verify the event appears in GA4 DebugView. This catches device-specific or browser-specific issues that wouldn't surface from a single desktop test.
Next, compare your GA4 event count against your form builder's native submission count over the same time period. A small discrepancy is normal. Ad blockers, browser privacy settings, and network issues will prevent some GA4 events from firing. But if the gap is larger than roughly 5-10%, something is likely misconfigured. Common culprits include AJAX submission issues (covered in Step 3), the GTM container not loading on all pages, or the Form Submission trigger scoping being too narrow or too broad.
Once you're confident in data quality, set up a GA4 Custom Alert. Navigate to Admin > Custom Alerts and create an alert that notifies you if form submission volume drops significantly below your baseline. This is your safety net. Tracking breaks happen, and without an alert, you can lose weeks of data before anyone notices. A proactive alert means you catch the issue within a day or two.
From there, build a recurring review rhythm. A monthly review of your form performance report is a reasonable cadence for most teams. Look for three things: overall conversion rate trends over time, pages with high traffic but low conversion rates (these are your highest-leverage optimization opportunities), and traffic sources that drive volume but few actual submissions (these may warrant budget reallocation).
Use what you're seeing to drive actual changes. If your funnel report shows a large drop-off before submission, test reducing the number of fields, changing the form headline, or moving the form higher on the page. If a particular traffic source consistently converts well, consider increasing investment there. The data is only valuable if it informs decisions.
For teams wanting to connect form submission data to downstream workflows like CRM updates or automated follow-up sequences, integrating your form builder with tools like Zapier can close the loop between GA4 insights and your actual sales process.
Success indicator: You have a documented baseline conversion rate for each key form, a custom alert configured for submission volume drops, and a recurring review scheduled in your team calendar.
Your Complete Setup Checklist
With these seven steps complete, you now have end-to-end visibility into how your forms are performing, from the first page view to the confirmed submission. That data transforms form optimization from guesswork into a systematic, measurable process.
Here's your quick reference checklist to confirm everything is in place:
1. GA4 property verified with Measurement ID confirmed and DebugView showing live hits
2. Google Tag Manager installed and confirmed firing via Preview mode
3. Form Submission trigger created with Wait for Tags and Check Validation enabled
4. GA4 Event tag configured with generate_lead event name and form_id, form_name, and page_location parameters
5. Key Event marked in GA4 Admin and appearing in engagement reports
6. Custom Exploration report built with funnel analysis and traffic source segmentation
7. QA validation completed across devices, discrepancy check done, and custom alert configured
The next step is to use what you're seeing. If your funnel report shows strong traffic but low submission rates, that's a form design and UX problem worth solving directly. The forms themselves matter as much as the tracking around them.
Orbit AI's form builder is built for exactly this kind of high-growth team context, with conversion-optimized layouts, AI-powered lead qualification, and native analytics integrations that make tracking setup faster and form performance data more actionable. Explore how Orbit AI can help your team capture and qualify more leads at orbitforms.ai, or start building free forms today and see how intelligent form design can elevate your conversion strategy.
