Google Ads Auto-Tagging and GCLID: Why Your Clicks Never Match GA4 Sessions, and Where the Gap Actually Lives

Open Google Ads and it says your campaign got 1,000 clicks last week. Open GA4 and it shows 740 sessions from google / cpc. Somebody in the room says the tracking is broken. Somebody else says that’s normal. A third person suggests Google is overcharging you, and now the meeting is about trust instead of marketing.

Nearly every advertiser who connects the two tools hits this wall. The frustrating part is that both answers, “broken” and “normal,” are sometimes correct, and the numbers alone don’t tell you which one you’re dealing with. A gap can be a harmless counting difference, or it can be a redirect quietly deleting the click ID from every visitor you pay for. Those two situations look identical on a dashboard and have very different consequences for your bidding.

This post covers what auto-tagging and the GCLID actually do, the legitimate reasons clicks and sessions differ, the failure modes that are costing you data, and a repeatable way to work out which bucket your account falls into. I’m leaning on Google’s own troubleshooting documentation where it exists and flagging clearly when something comes from a third-party write-up instead, because plenty of advice on this topic is folklore repeated across blogs.

Clicks and sessions are two different things

Before anything gets debugged, it helps to accept an uncomfortable fact: a Google Ads click and a GA4 session are not the same unit, so they were never going to match one-to-one.

A click is recorded by Google Ads at the moment someone clicks your ad, before their browser has loaded anything from your site. A session is recorded by your analytics tag, which only exists if the page loads and the tag fires. Between the click and the session sit a redirect (maybe), a network, a browser, a consent banner, a script loader, and the patience of a person on a phone with one bar of signal. Any of those can end the journey before analytics knows it started.

Google’s Ads Help page on this exact problem, “Clicks and Sessions Discrepancy for Google Ads and Google Analytics,” lists several built-in reasons the counts diverge. In plain terms they are:

• Invalid click filtering. Google Ads filters out clicks it considers invalid, while Analytics initially reports all the sessions it sees before any filtering. So your Ads number can be lower for this reason alone, not higher.
• The tag didn’t load in time. A person can click your ad and then close the tab or navigate away before the analytics code on the landing page finishes loading. Ads counted a click. Analytics never saw a visit.
• Auto-tagging is off. Without it, the click ID isn’t added to your landing page URL, and sessions can’t be tied back to the ad click.
• The click ID gets stripped. Redirects, cross-domain journeys and URL-cleaning scripts can remove the GCLID before the final page loads.
• Repeat clicks. If someone clicks your ad twice within a 30-minute window without closing their browser, that’s two clicks but only one session.
• Mixed tagging. Using both manual tagging and auto-tagging on the same destination URLs can create discrepancies between GA4 and Google Ads.

Notice what that list implies. Some of these (invalid clicks, repeat clicks) are just how the two systems count, and nothing you do will make them match. Others (auto-tagging off, stripped click IDs, mixed tagging) are configuration problems you can fix. The skill in debugging this is separating the first group from the second, and not spending a week “fixing” something that isn’t broken.

What auto-tagging actually does

When auto-tagging is on, Google Ads appends a parameter called the GCLID (Google Click Identifier) to the final URL of your ad. It’s a long, opaque string that looks like ?gclid=EAIaIQobChMI... and is unique to that click. You don’t create it, and you can’t read anything useful out of it by eye.

Its job is to be a receipt. When the visitor lands on your page, your analytics tag reads the GCLID, and because the GCLID is tied to a specific click in Google Ads, Analytics can look up which campaign, ad group, keyword and ad produced that visit. That’s the mechanism that makes GA4’s Google Ads reports possible. It’s also the mechanism that lets you upload an offline conversion later, such as a closed deal in your CRM, and have Google Ads credit the original click. (I get into that side of things in the post on offline conversion imports.)

Google’s documentation on GA4’s benefits of auto-tagging says that when both auto-tagging and manual parameters are present, attribution is based on the GCLID, and manual parameters are only used when no GCLID is available. The auto-tagging help page makes the same point from the other direction: in GA4, auto-tagging is prioritized over manual tagging, and there is no override option. In the old Universal Analytics there was a setting to let manual tags win. GA4 doesn’t have one.

Auto-tagging also unlocks detail that manual tags can’t carry. Google notes that with auto-tagging you can see additional dimensions such as ad group, keyword text and the campaign’s customer ID, while manual tagging covers a more basic set of traffic-source fields. If you’ve ever opened a GA4 report and wished it could show you which keyword drove the sessions, that depth comes from the GCLID.

So the short version: leave auto-tagging on. If your account has it off, that’s almost certainly your first fix, and it’s one checkbox in the account settings.

The 10 to 20 percent question

Everyone wants to know how big a gap is acceptable. I wish there were an official answer. Google doesn’t publish a threshold. The number you’ll see quoted most often comes from third-party sources, and I’d treat it as a rule of thumb: one blog says a 10 to 20 percent gap between clicks and sessions is typical, and that anything beyond about 30 percent suggests a real problem.

That’s a reasonable sanity check, but it isn’t a law. A site with a heavy, slow-loading landing page and a lot of mobile traffic will lose more visitors before the tag fires than a lightweight page on fast connections. A brand-new account with 40 clicks a week will bounce around enough that the percentage means nothing. Use the range to decide whether to look closer, not to decide you’re fine.

A better question than “how big is the gap” is “where does the gap live.” A uniform 15 percent shortfall across every campaign is probably the ordinary friction of the web. A shortfall that’s 5 percent on desktop and 45 percent on mobile, or 10 percent on most campaigns and 60 percent on one, is pointing at something specific. Which brings us to the segmentation step later in this post.

When sessions are higher than clicks

This one confuses people more than the usual direction, so it deserves its own section. It’s possible, with auto-tagging on, to see more sessions in GA4 than clicks in Google Ads.

Google’s troubleshooting page explains a couple of ways this happens. The common one is bookmarks and shared links. If someone clicked your ad, landed on a URL with the GCLID still attached, and then bookmarked that page or sent the link to a colleague, every later visit through that URL carries the same GCLID. Analytics attributes the visit to the ad, even though no new click happened and you weren’t charged for it. Google also notes that if a user comes back to your site directly, those additional sessions can have their campaign source reported as the last-known campaign.

The practical effect is that your paid channel in GA4 gets credit for some returning visitors who were not generated by that day’s spend. It isn’t a huge distortion in most accounts, but it matters in two cases. First, if you’re comparing click cost against GA4 sessions to calculate cost per session, the denominator is inflated. Second, if you have a B2B product with long consideration cycles and people forward your landing page URL internally, the paid channel can look better than it is.

Auto-tagging and manual UTMs: how they interact

A lot of accounts have both. Someone set up UTM parameters years ago because that was the best practice, then someone else turned on auto-tagging because Google told them to. Nobody removed the old UTMs. Usually everything keeps working, which is how the situation survives for years.

Here’s what happens in GA4 under Google’s stated rules. If a visitor arrives with a GCLID, GA4 uses the GCLID for attribution and the UTMs are ignored for the purposes of Google Ads reporting. If a visitor arrives with UTMs but no GCLID, because it got stripped, the UTMs take over. That second case is where a “belt and suspenders” setup can actually help, since the UTMs act as a fallback when the click ID is lost.

There’s a more worrying claim in circulation, from a third-party guide: that if the landing URL has at least one UTM parameter, GA4 derives all its cross-channel dimensions only from the UTM values. I can’t verify that from Google’s documentation, so I won’t present it as fact. If you run a mix of partial UTMs (say, utm_source but no utm_medium), it’s worth testing in your own property, because a half-filled UTM set is a classic way to end up in “(not set)” or “Unassigned” territory.

A 2026 guide from Terminus recommends a clean pattern that I think is sensible: keep auto-tagging on, and if you want your own descriptive labels, add them through the Final URL Suffix field rather than hand-editing every final URL, and keep the naming consistent with a controlled vocabulary. The point of that last part is dull but important. If one campaign says cpc, another says ppc and a third says paid-search, your reports will fragment no matter how perfect the underlying tracking is.

If you’re cleaning this up, don’t do it blind. Change one thing, then check that sessions from your paid campaigns still appear under the right source and medium in GA4. The Google Ads change history is useful here, because it gives you a dated record of when tracking templates or suffixes changed, which you can line up against any step-change in GA4 numbers.

How the GCLID gets lost on the way to your page

The scariest cause of a click-session gap is also the least visible one: the GCLID is present when the visitor leaves Google, and gone by the time they reach the page where your tag lives. The session is still recorded in some cases, but it arrives with no ad attribution, so it lands in direct, unassigned or organic instead of paid.

These are the usual mechanisms.

Redirects that don’t preserve the query string

If your ad URL goes to a short link, a regional redirect, a language switcher, a “www” to non-“www” rule, or an http to https upgrade, each hop is a chance to drop the parameters. One developer write-up on the topic, a single author’s test and not an official source, describes a redirect setting called “preserve query string.” With it off, which was the default in the tool tested, the incoming GCLID is dropped. With it on, the incoming parameters are forwarded but any query string on the target URL is discarded, so one rule can’t forward the click ID and also append a parameter of your own.

The exact setting names vary by CMS, host and CDN, so verify the behavior in whichever redirect tool you use. The principle holds everywhere: every redirect between the ad and the final page is a place the GCLID can die, and you should know what each one does with a query string.

Tracking templates and third-party click trackers

A tracking template sends the click through another URL before it reaches your page. That can be a legitimate analytics or call-tracking vendor, or an old affiliate tool somebody added years ago. If the template doesn’t pass the destination URL through correctly (the {lpurl} placeholder is how you refer to the final URL), you can end up with broken landing pages or missing parameters. The advice that shows up consistently in practitioner guides is to test the entire chain with the real template before putting it live, and to re-test whenever you change a vendor.

URL-cleaning scripts and consent tools

Some privacy tools, tag-manager recipes and “clean URL” scripts remove query parameters from the address bar after the page loads, often for cosmetic reasons. If that script runs before your analytics tag reads the GCLID, the tag never sees it. Google’s troubleshooting page explicitly mentions URL-cleaning scripts as a cause.

Consent tools can interfere in a different way. If your consent banner delays the analytics tag so long that the page view happens without it, you lose the session entirely, not just the attribution. This is worth reading alongside our post on Consent Mode v2, since consent configuration and click-ID handling are closely related but often owned by different people.

Cross-domain journeys

If your ad lands on one domain and the visitor moves to another to complete the action, such as a booking system or a hosted checkout, session continuity breaks unless cross-domain measurement is set up. The visitor shows up on the second domain as a new session whose source is the first domain, and the paid attribution is lost at the handoff. This is one of the most common causes of “our ads get leads but GA4 says they came from referral.”

Browser and privacy behavior

Browsers and operating systems have been trimming tracking parameters for years. Two parameters you’ll see in the wild besides the GCLID are the wbraid and the gbraid. According to practitioner write-ups, wbraid was introduced in March 2021 for web conversions on iOS where the device advertising ID can’t be read, and gbraid in May 2021 for app deep-link conversions on iOS. They exist because iOS limits what can be passed in a click ID, so Google issues a different identifier in those situations.

There are also reports, from vendor blogs, that some Safari modes strip click identifiers when a link is opened from Mail or Messages or in Private Browsing, and one vendor post describes an upcoming release that would remove click IDs even in ordinary sessions. I haven’t been able to confirm that second claim from an official source, so I’d treat it as something to watch rather than a settled fact. What is settled is the practical consequence: you shouldn’t build anything that assumes a GCLID will always be there.

Why this matters beyond reporting

It’s tempting to file all of this under “analytics hygiene” and move on. The reason it belongs in a Google Ads conversation is that your conversion data feeds your bidding.

When the click ID is lost on the way to your site, a few things can go wrong downstream.

• Offline conversions can’t be matched. Google’s documentation says auto-tagging must be enabled to import offline conversions using GCLIDs, and an uploaded conversion needs one of GCLID, WBRAID or GBRAID. If your form never captured the click ID because it was stripped upstream, your CRM has nothing to send back. (If you store only the GCLID and a share of your iOS traffic arrives with a WBRAID or GBRAID instead, you’re quietly discarding those leads from the feedback loop. Store whichever identifier arrives.)
• The 90-day window is real. Google’s offline conversion help text says conversions uploaded more than 90 days after the associated click won’t be imported. For a long B2B sales cycle, that’s a hard deadline, so a lead that closes in month four can’t be credited if you only try to send it then.
• Smart Bidding learns from what it sees. If good leads are invisible to Google Ads because their click ID was lost, the bidder under-values the audiences and queries that produce them. You may not notice, because the campaign still looks like it’s “working” on the conversions that did get through. The post on how much conversion data Smart Bidding needs covers why thin or skewed data is more damaging than it looks.
• Your own judgment of campaigns gets distorted. If paid sessions are leaking into direct and unassigned, you may cut a campaign that’s performing, or credit organic with something paid delivered.

This is why it pays to treat a click-session gap as a symptom worth explaining rather than shrugging at. The gap itself is rarely the problem. What the gap is hiding usually is.

A diagnostic you can run in an afternoon

Here’s an order of operations that goes from cheapest to most involved. Stop as soon as you find something that explains most of the gap.

Step 1: Confirm auto-tagging is actually on

In Google Ads, open your account settings and check the auto-tagging option. Do this at the account level, and remember that if you manage multiple accounts under a manager account, each one has its own setting. It sounds too basic to check, but accounts get restructured, reconnected and handed between agencies, and this is one of the settings that quietly reverts or gets missed on a new sub-account.

Step 2: Confirm the link between Google Ads and GA4 is healthy

Check that the right Google Ads account is linked to the right GA4 property, that data sharing options you expect are on, and that only the accounts you intend are linked. One practitioner guide advises against linking multiple Google Ads accounts to the same property if you can avoid it, because the combined reporting gets harder to reason about. That’s advice, not a rule, but it’s worth knowing if you manage several brands.

Step 3: Click your own ad and inspect the URL

This is the single most useful test, and almost nobody does it. Search for one of your own keywords (use a different browser profile so you aren’t logged in to anything that affects results), click your ad, and look at the address bar when the page loads. Is there a gclid= parameter? If you can open the browser’s developer tools and watch the network tab, you can see every redirect between the ad and the page and what each one does with the query string.

Be careful about one thing: clicking your own ads costs you money and may be filtered as an invalid click. Do it sparingly. A better version, if you have a tracking template, is to use the “test” function next to the template in Google Ads, which checks that the final URL resolves and doesn’t spend a click.

If the GCLID is on the URL when you click but gone on the final page, you’ve found a stripping problem and now you just need to find which hop did it. Walk the chain one redirect at a time.

Step 4: Watch a session arrive in GA4 DebugView

Even with the GCLID intact, the session might still not carry the right source. In DebugView, check that session_start fires and that the page view includes the click ID. Third-party troubleshooting guides on “(not set)” traffic point at a few repeat offenders: a missing or misfiring session_start, events firing before the Google tag has initialized so there’s no client or session ID, consent configuration that delays tag initialization, and mixed routing where some events go through a server container and others go directly to Google. A related point from the same sources: sending events with the Measurement Protocol and generating a fresh session ID each time makes GA4 treat every event as a new session, often without source or medium.

It’s also useful to know that “Unassigned” and “(not set)” are different problems. Guides on this describe Unassigned as typically a channel grouping issue (GA4 had source and medium but no rule matched them), while “(not set)” means the source data is missing altogether. They have different fixes, so check which one you have before changing anything.

Step 5: Segment the gap before you try to fix it

Pull clicks from Google Ads and sessions from GA4 for the same date range and break both down by campaign, device and landing page. You’re looking for concentration. A gap that’s the same everywhere is ordinary friction. A gap that’s concentrated in one place has an address.

• One campaign: check its final URLs, tracking template, final URL suffix and whether it uses a different landing page or domain from the rest.
• Mobile only: suspect page speed, tag loading, the in-app browser, or iOS click ID behavior.
• One landing page: check whether that specific page is missing the analytics tag, runs a consent script differently, or sits behind a redirect.
• One country or region: consent rules often differ by location, and that’s where tags are most likely to be blocked or delayed.

While you’re in the data, make a note of the date the gap changed. If it widened at a specific point, that’s the strongest clue you’ll get. Line it up against your change history, site deployments, consent-tool updates and tag-manager publishes.

Step 6: Check the conversion side too

Clicks and sessions aren’t the only numbers that drift. Conversions imported from GA4 and conversions tracked by the Google Ads tag will also differ, for related reasons. If you’re reconciling those, our guide to auditing conversion tracking walks through the checks, and the post on enhanced conversions covers a method that helps when the click ID isn’t enough on its own.

Fixes, in rough order of payoff

Once you’ve located the problem, the fixes tend to be undramatic. Here’s the sequence I’d follow, roughly by how often each one turns out to matter.

1. Turn auto-tagging on, if it isn’t. Then stop mixing it with hand-built UTMs on the same final URLs unless you’ve decided on purpose to keep them as a fallback.
2. Make every redirect preserve the query string. Or remove the redirect by pointing your ads directly at the final URL. The fewer hops between click and page, the fewer places to lose the click ID, and the faster the page loads.
3. Load your analytics tag as early as you reasonably can on landing pages. Visitors who leave before the tag fires are invisible to GA4 no matter how perfect the rest of the setup is. Lighter pages narrow the gap on their own.
4. Fix cross-domain handoffs. If the journey crosses domains, configure cross-domain measurement so the session carries over.
5. Capture the click ID in your forms. Add hidden fields that store the GCLID, WBRAID and GBRAID from the URL, and pass them into your CRM so offline imports have something to send back. Test with a real form submission and confirm the value arrives in the CRM record.
6. Use a Final URL Suffix for labels you want, rather than editing every URL. Keep naming consistent and document it somewhere other people can find.
7. Review consent behavior. Make sure tags initialize in a way that respects consent while still recording the session where it’s allowed.

After each fix, give it enough time to produce data before judging it, and compare like with like. The numbers for the last day or two are often still being processed, so a gap you measure on yesterday’s data will look worse than it is. Do the comparison on a settled window.

What to accept and stop worrying about

Chasing a perfect match between the two tools is a good way to burn a month. Some of the gap is structural and will always be there. Invalid click filtering means Ads and Analytics disagree on what counts. Repeat clicks collapse into one session. People close tabs. Ad blockers block analytics tags. A shared link carries a GCLID into sessions you didn’t pay for.

What you want is a gap that’s stable, roughly explainable and not concentrated in any one place. If next month’s gap is about the same as this month’s, and you can account for it in broad terms, you have a healthy setup. If it’s lurching around or growing, something changed and you should go find it.

It’s also worth deciding in advance which source you trust for which question. Google Ads is the system of record for what you were charged and how many clicks you received. GA4 is better for on-site behavior and, when the click ID survives, for connecting that behavior to the campaign. Your CRM is the system of record for what turned into revenue. Arguments get shorter when each tool has a defined job.

Keeping an eye on it without a monthly audit

The reason this problem lingers is that nothing announces it. Tracking rarely breaks with a bang. A developer ships a redirect rule, a consent vendor updates its script, someone adds a new landing page without the tag, and the effect shows up as a slow drift in a number that few people reconcile. By the time the quarterly review notices, you’ve fed weeks of skewed data into your bidding.

That’s the kind of thing that benefits from being watched daily rather than audited occasionally. Growera’s Google Ads manager monitors an account continuously, so a sudden change in click-to-conversion patterns on one campaign, or a conversion action that stopped recording, gets surfaced when it happens instead of at the next review. It won’t rewrite your redirect rules for you, and it can’t see inside your website’s code, so the fixes above still need a person or a developer. What it shortens is the gap between something breaking and you knowing about it. If you’re comparing tools for that job, the pricing page lays out the plans, and the homepage gives the overview.

Summary

Clicks in Google Ads and sessions in GA4 are different measurements, so a gap is expected. According to Google’s own troubleshooting page, the built-in reasons include invalid click filtering, tags that didn’t load before the visitor left, and repeat clicks inside 30 minutes. The reasons you can fix are auto-tagging being off, the GCLID being stripped by redirects or scripts, and mixing manual tagging with auto-tagging. Sessions can even exceed clicks when bookmarked or shared URLs keep carrying an old GCLID.

The rule of thumb that a gap of 10 to 20 percent is ordinary and 30 percent or more deserves investigation comes from a third-party source, not Google, so use it only to decide where to look. Where the gap lives matters more than its size: split it by campaign, device, landing page and region, and note when it changed.

• Keep auto-tagging on. In GA4 it takes precedence over manual tagging, and it unlocks keyword and ad group detail.
• Click through your own ad, or test the tracking template, and confirm the GCLID survives every redirect.
• Check DebugView for a clean session_start and correct source on a paid visit.
• Capture GCLID, WBRAID and GBRAID in your forms and CRM, and remember offline imports have a 90-day limit from the click.
• Set a baseline gap, watch for changes, and compare against change history when it moves.

Treat the gap as a clue. A steady one is just the cost of measuring the web. A sudden or lopsided one usually means a specific, findable thing is wrong, and finding it protects the data your bidding depends on.

Sources

• Clicks and Sessions Discrepancy for Google Ads and Google Analytics: Troubleshoot (Google Ads Help)
• About auto-tagging (Google Ads Help)
• [GA4] Benefits of Google Ads auto-tagging (Google Analytics Help)
• Set up offline conversions using Google click ID (Google Ads Help)
• Third-party material referenced above: Terminus on auto-tagging versus manual UTMs in 2026, Wicked Reports on gclid, gbraid and wbraid, a developer write-up on redirects dropping the GCLID, and several GA4 “(not set)” and Unassigned traffic troubleshooting guides.