GA4 Conversion Tracking: The Complete Setup Guide

Why Conversion Tracking Comes Before Everything Else

Every marketing decision downstream of your analytics inherits the quality of your conversion tracking. If your tracking fires twice on some submissions and not at all on others, your cost per lead is fiction, your A/B tests are noise, and — most expensively — Google’s Smart Bidding algorithms are optimizing toward the wrong signal with your money. We audit a lot of accounts, and broken or partial conversion tracking is the single most common defect we find: forms that only track when the user lands on a thank-you page that half of them never reach, phone calls that aren’t tracked at all, and purchase events that double-fire on page refresh.

The fix isn’t complicated, but it has to be done in a particular order: understand GA4’s event model, set up clean event collection through Google Tag Manager, flag the right events as key events, connect the data to Google Ads, and then verify all of it with the debugging tools Google provides. This guide walks through that exact sequence.

One scope note before we start. This is not a guide to creating a GA4 property or installing the base tag — that’s table-stakes setup covered elsewhere. This guide assumes GA4 is already collecting pageviews on your site and focuses entirely on the part most setups get wrong: tracking the actions that actually make you money.

Key Events vs. Conversions: Get the Terminology Right

GA4 changed its vocabulary in 2024, and understanding the change saves a lot of confusion when you’re reading documentation or talking to Google support.

In GA4, everything is an event — a pageview, a scroll, a click, a form submission, a purchase. There is no separate hit type for conversions the way there was in Universal Analytics. When an event represents an action you care about, you flag it as a key event. This is a toggle in the GA4 admin interface: under Admin, then Events, you flip the switch labeled “Mark as key event” next to the event name, or you create the key event by name under the Key events section before the event has even fired for the first time. Once flagged, that event populates the key events metrics in your reports and becomes eligible for import into Google Ads.

The word “conversion” still exists, but Google now reserves it for the advertising side: a conversion is what Google Ads counts when a key event (or a Google Ads conversion action) is attributed to an ad interaction. So the same form submission is a key event in your GA4 reports and a conversion in your Google Ads reports — and the two numbers will rarely match exactly, because the platforms use different attribution logic, different counting windows, and different rules about which interactions get credit. That discrepancy is normal and expected. What matters is that the underlying event is firing once per real action, every time.

A practical naming note: use Google’s recommended event names where they exist — generate_lead for lead forms, purchase for transactions — because GA4 and Google Ads have built-in handling for recommended events, and future features tend to support them first.

The GTM Foundation: One Container, Clean Architecture

You can send events to GA4 with hardcoded gtag.js snippets, but don’t. Google Tag Manager gives you version control, a preview mode, and the ability to change tracking without touching site code. Every serious setup runs through GTM.

The architecture has three layers. First, the Google tag (the artist formerly known as the GA4 Configuration tag) fires on every page and establishes the connection to your GA4 property via your measurement ID. Second, GA4 event tags fire on specific triggers and send named events — generate_lead, phone_call, purchase — with whatever parameters you attach. Third, triggers and variables define when those tags fire and what data they carry.

Before you build anything, write a measurement plan: a simple table listing every action worth tracking, the event name you’ll use, the parameters it needs, and whether it should be a key event. For a typical service business that’s five to eight rows — lead form submission, phone click, quote request, booking, maybe a newsletter signup as a secondary signal. For e-commerce it’s the standard funnel: view_item, add_to_cart, begin_checkout, purchase. The plan keeps your event names consistent, and consistency is everything: GA4 treats Generate_Lead, generate-lead, and generate_lead as three different events, and a misspelled event name silently fails to match the key event you defined.

A word on GA4’s enhanced measurement, which offers automatic form tracking out of the box. Its form_submit event fires on the browser’s submit event — including submissions that fail validation, search boxes, and newsletter footers — and it often misses modern JavaScript forms entirely. Treat enhanced measurement’s form events as a rough signal, never as your key event. Your real lead tracking should be deliberate, which is what the next section covers.

Tracking Form Submissions the Right Way

There are three common ways to track a form, in ascending order of reliability.

The thank-you page method fires your event tag on a pageview of the confirmation URL. It’s simple and it works — if every successful submission reliably redirects to a dedicated page that users can’t reach any other way. Both conditions fail constantly in practice: AJAX forms that show an inline success message without redirecting, thank-you pages that get indexed and visited directly, and multi-purpose confirmation pages that inflate counts. If you use this method, make the thank-you page noindex and verify the redirect actually happens on every form on the site.

The element-visibility method uses GTM’s element visibility trigger to fire when the inline success message appears. It handles AJAX forms without code changes, but it’s brittle: a CSS class rename during a site update silently kills your tracking, and nobody notices for weeks.

The dataLayer method is the gold standard. Your developer adds one line to the form’s success callback — a dataLayer.push with an event name like form_submission_success and parameters identifying which form it was. In GTM, a custom event trigger listens for that push and fires a GA4 event tag named generate_lead, carrying a form_id or form_name parameter so you can tell your contact form from your quote form in reports. Because the push only happens when the server confirms success, you count real submissions: no validation failures, no double-counting, no dependency on URLs or CSS classes. Most form plugins and platforms — Gravity Forms, HubSpot, Webflow, Contact Form 7 — either push dataLayer events natively or have a documented hook where one line of JavaScript does it.

Whichever method you use, flag the resulting event as a key event in GA4 admin, and only the success event — never the form_start or generic form_submit noise.

Tracking Phone Calls: The Conversions Everyone Forgets

For local and service businesses, calls are often the majority of conversions — and the majority of setups don’t track them at all, which means GA4 reports systematically undervalue exactly the channels that drive calls.

The baseline is click-to-call tracking, and it takes ten minutes in GTM. Create a trigger of type Just Links with the condition Click URL starts with tel:, then attach a GA4 event tag — call it phone_call_click — that captures the clicked number as a parameter. Mark it as a key event. This catches every tap on a phone link from mobile and every click from desktop. Its limitation is honesty by another name: it counts intent to call, not completed calls, and it misses people who read the number off the screen and dial manually.

To close that gap you need either Google’s own call tracking or a third-party platform. Google Ads offers call assets and Google forwarding numbers that record calls driven directly by ads, including duration, so you can count only calls longer than a threshold as conversions. Dedicated call tracking platforms — CallRail and its competitors — go further with dynamic number insertion: the phone number displayed on your site swaps per visitor based on their traffic source, the platform attributes each call to its session, and it pushes a completed-call event into GA4 and Google Ads with duration and caller data attached.

Whether dynamic number insertion is worth its monthly cost depends on call volume; for a business where the phone is the primary conversion path, it usually pays for itself in attribution clarity alone. At minimum, implement the tel: click event today — it’s free, and going from zero call data to directional call data changes how you read every acquisition report.

Tracking Purchases: Transaction IDs or It Didn’t Happen

E-commerce tracking in GA4 revolves around the purchase event, and it’s stricter than lead tracking because it carries money. The event needs three things to be useful: a transaction_id, a value, and a currency parameter — plus an items array describing what was bought if you want product-level reporting.

The transaction_id is non-negotiable, and it’s the parameter most broken setups omit. GA4 uses it to deduplicate: if the same transaction_id arrives twice — because the customer refreshed the order confirmation page, or returned to it from an email a day later — GA4 can recognize the duplicate within the same session context, and Google Ads uses transaction IDs to deduplicate imported conversions. Without it, every confirmation-page reload is counted as revenue, and your ROAS reporting drifts upward into fantasy. Even with it, the best practice is to fire the purchase event from a one-time dataLayer push generated server-side on order completion rather than from a bare confirmation pageview.

If you’re on Shopify, WooCommerce, or a similar platform, you don’t hand-build this: Shopify’s native Google channel integration and the established GTM data layer plugins for WooCommerce push properly structured ecommerce events for the whole funnel. Your job is verification, not construction — confirm in DebugView that one test order produces exactly one purchase event with the right value, the right currency, and a populated items array.

Two details that bite people: currency mismatches (a Canadian store sending value without currency: CAD can be misread by downstream systems), and tracking the purchase event on payment-provider domains where your GTM container doesn’t load — if your checkout bounces through a third-party payment page, test the full real path, not the shortcut your developer uses.

Linking Google Ads and Importing Key Events

Clean GA4 data only pays off when it reaches the platform spending your budget. Linking is the easy part: in GA4, go to Admin, then Product links, then Google Ads links, and connect your Google Ads account (you need edit access in GA4 and admin access in Google Ads). Turn on personalized advertising in the link settings if you want GA4 audiences available for remarketing.

Importing is where decisions live. In Google Ads, under the conversions section, you import your GA4 key events as conversion actions. Each imported action gets two settings that matter enormously. First, primary versus secondary: primary conversions feed Smart Bidding; secondary conversions are observed but don’t influence bids. Your real revenue events — purchase, generate_lead, qualified phone calls — should be primary. Soft signals like newsletter signups belong in secondary, because if you mark them primary, the algorithm will happily buy you cheap newsletter subscribers instead of customers. Second, counting: leads should usually count once per interaction (one click producing three form submissions is still one lead), while purchases count every occurrence.

Avoid the classic double-counting trap: if you import a GA4 key event and also run a native Google Ads conversion tag for the same action, and both are primary, every conversion counts twice and Smart Bidding learns from inflated data. Pick one source per action.

Finally, enhanced conversions. Because browsers increasingly restrict third-party cookies, Google Ads can lose the thread between an ad click and a conversion. Enhanced conversions patch this by sending hashed first-party data — typically the email address or phone number the customer already gave you at checkout or on the form — alongside the conversion. The data is hashed with SHA-256 before it leaves the browser, Google matches it against signed-in accounts, and conversions that would otherwise be unattributable get recovered. In a GTM setup, you enable it on the conversion tag and supply a user-provided data variable pointing at the field values or a dataLayer push. It’s one of the highest-leverage flips in modern measurement, and for lead-gen businesses, enhanced conversions for leads can also connect offline sale outcomes back to the original ad click.

Debugging: Tag Assistant and DebugView Before You Trust Anything

Never ship tracking changes on faith. The verification workflow takes fifteen minutes and uses two tools that look at the same events from opposite ends of the pipe.

Tag Assistant is GTM’s preview mode, launched from the Preview button in your container or at Google’s Tag Assistant site. It opens your site in a debug session and shows you, event by event, which tags fired, which didn’t, and why — which trigger matched, what every variable resolved to, and the exact payload each tag sent. This is where you catch the trigger that never matches because the dataLayer event name has a typo, or the variable that resolves to undefined because the CSS selector changed. Walk through your entire conversion path here: load the page, submit the form with real-ish data, click the phone number, complete a test purchase if you can.

DebugView is the receiving end, found in the GA4 admin. While you’re in a Tag Assistant session (or with debug_mode enabled), your events stream into DebugView in near real time, shown on a timeline with every parameter expanded. This is where you confirm GA4 actually received what GTM sent: the event name is exactly right, the parameters carry values rather than placeholders, and the key-event flame icon appears on events you’ve flagged. The combination matters because each tool catches what the other can’t — Tag Assistant proves the tag fired; DebugView proves the property received and recognized it.

Three closing checks: trigger each conversion exactly once and count the events (catching double-fires is the whole point), test from a phone as well as a desktop because mobile behavior differs, and remember that standard GA4 reports run on a processing delay — don’t panic when this morning’s test isn’t in yesterday’s-style reports yet. DebugView and the Realtime report are your same-day truth.

The Mistakes That Quietly Ruin Conversion Data

After the setup is live, most tracking damage comes from a short list of recurring mistakes. Audit your own property against these.

Marking every event as a key event. If scroll, click, and session_start are key events, your key-event metrics mean nothing and any import into Google Ads poisons bidding. Be ruthless: key events are actions with business value, usually three to six of them.

Double-counting from overlapping sources. The same form tracked by enhanced measurement’s form_submit, a thank-you page trigger, and a dataLayer event — with two of them flagged as key events. One action, one event, one source.

No transaction deduplication. Purchase events without transaction_id, firing on every confirmation-page load. Your revenue chart looks great right up until someone reconciles it against the order system.

Testing pollution. Your own team’s form tests and test orders counted as conversions. Define internal traffic rules in GA4 admin and filter internal IPs, and use GA4’s test-data filters during development.

Consent and blocking blindness. A consent banner that blocks tags for users who decline means a portion of real conversions never get recorded — that’s the gap between your CRM’s lead count and GA4’s. You can’t eliminate it, but you should know its size, configure consent mode so Google can model some of what’s missing, and resist “fixing” it by firing tags before consent.

Set-and-forget. Tracking breaks silently — a site redesign, a form plugin update, a checkout migration. Put a monthly fifteen-minute check on the calendar: trigger each key event once, watch DebugView, compare GA4’s weekly lead count against the CRM. That single habit catches in days what most businesses discover after a quarter of bad decisions.

Get this foundation right and everything downstream — bidding, budgeting, reporting, testing — finally runs on numbers you can trust. It’s unglamorous work, which is exactly why it’s the highest-leverage afternoon in digital marketing; it’s also the first thing we fix at SearchPod before touching a single campaign setting.