Google Consent Mode v2 tells Google’s advertising and analytics tags how to behave after a visitor answers a cookie banner. When the visitor accepts, the tags send their normal signals. When the visitor declines, the tags either stay silent or send a reduced, cookieless request, depending on how you set it up. Version two added two signals, ad_user_data and ad_personalization, which Google introduced in November 2023 and enforced more widely through 2024.

When a visitor declines, Google’s tags can’t use cookies to recognize them, so their visits and conversions can’t be tied to a returning user or an earlier ad click in the usual way. In Basic mode nothing reaches Google for that visitor. In Advanced mode the tags still send cookieless pings directly, and that’s the material Google works from. Behavioral modeling estimates the users and sessions Google could not see, and conversion modeling estimates the key events and attribution that were lost.

This article covers the four signals, the two modes, the setup code, and where modeling stops. Part of it comes from a live site. On 2026-10-13 we clicked through a real cookie banner on a Brazilian client’s site in headed Chrome, one stage at a time, and read the consent value on every Google hit. The results and the defect we found are further down. The wider mechanics of cookie-based measurement are in the server-side tracking guide and the first-party versus third-party cookies guide.

Version two added two signals to the original two

Version two did not replace the original framework. Google’s tags now read four consent types, and each one controls a specific kind of storage or data flow.

Consent signal What it controls
ad_storage Whether cookies related to advertising can be written and read
analytics_storage Whether cookies related to analytics, such as session duration, can be written
ad_user_data Whether user data may be sent to Google for advertising
ad_personalization Whether user data may be used for personalized advertising

The first two are the original Consent Mode and govern storage on the visitor’s device. The two new ones govern whether data about the user is sent to Google and used for ad personalization at all, whatever is stored locally. Google added them to align with the Digital Markets Act and its EU User Consent Policy.

The “v2” is not a new tag or a separate product. It refers to the two extra parameters inside the same consent state your tags already read. A setup that sends only ad_storage and analytics_storage is the old behavior and lacks the two signals the policy now expects for the applicable advertising features.

Flow diagram: a visitor answers the consent banner; granted consent produces a full event with parameters, denied consent produces a modelled estimate.
In Advanced mode a denied visitor still sends a cookieless ping that modeling can use. In Basic mode the visitor sends nothing, and only Google Ads' general model applies.

Who has to implement it

It depends on which products you use and where your users are. Google’s EU User Consent Policy covers end users in the European Economic Area, the UK and Switzerland (checked 2026-10-17). For those users it requires consent and the Consent Mode v2 signals for advertising measurement, remarketing and personalization. It does not make a custom Consent Mode build mandatory for every GA4 property. A site that uses GA4 only for aggregate analytics, with no Google Ads features, is in a different position from an advertiser running remarketing lists.

Requirements also differ by role. Publishers who serve personalized ads need a Google-certified CMP integrated with the Transparency and Consent Framework. Advertisers using Google Ads features for those users need the consent and the signals, and without them Google restricts the features. Outside those regions Google’s policy does not apply, but local law can add its own consent duties. Consent Mode reads a consent state and tells the tags how to act. Legal compliance comes from how you collect, store and document the choice, and that decision belongs to whoever owns your privacy position.

Basic and Advanced mode send different things

In Basic mode, the Google tags do not load until the visitor grants consent. A denied default is not enough on its own: Basic means the tags are blocked, through your consent tool or through GTM’s consent checks on each tag. Google’s Consent Mode overview says that in this mode no data reaches Google for a visitor who does not consent, “not even the consent status.” Google Ads can still estimate some lost conversions with a general model, but that model is not built from your own denied traffic.

In Advanced mode, the tags load with a denied default and send cookieless pings while consent is denied. That lets Google calibrate an account-specific model in Google Ads and makes GA4 behavioral modeling possible.

Basic mode Advanced mode
What is sent when consent is denied Nothing, not even the consent state A cookieless ping
Google Ads conversion modeling General model Account-specific model
GA4 behavioral modeling Not available Available, subject to eligibility

What the cookieless ping carries

A cookieless ping is not an anonymous empty packet. According to the same Google overview (checked 2026-10-17), it can include the timestamp, user agent and referrer, a flag showing whether the current or a prior page had ad-click information in the URL, the consent state, and a random number generated on each page load. What it leaves out is the advertising and analytics cookies.

With ad_storage denied, requests go through a different domain, such as pagead2.googlesyndication.com, so previously set third-party cookies are not sent. The full page URL is still collected, including a GCLID or DCLID in its parameters. That is what ads_data_redaction changes. Google’s setup guide says that when it is true and ad_storage is denied, ad click identifiers in requests from Google Ads and Floodlight tags are redacted. It has no effect when ad_storage is granted or when you do not use the gtag('consent') command.

url_passthrough answers a different question. It appends the ad click identifier to links within your domain so it survives a navigation when cookies cannot hold it. A setup can use both settings, either, or neither. Neither one carries the identifier through a checkout on another domain; that needs cross-domain measurement with its own linker configuration.

Setup: default first, then the tag, then the update

Order is where most setups break. Google says to call the default “before any commands” on every page, and that “if your consent code is called out of order, consent defaults won’t work.” For gtag.js:

<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}

  // 1. Default state, before any config or event command
  gtag('consent', 'default', {
    ad_storage: 'denied',
    ad_user_data: 'denied',
    ad_personalization: 'denied',
    analytics_storage: 'denied',
    wait_for_update: 500
  });
  gtag('set', 'ads_data_redaction', true);
  gtag('set', 'url_passthrough', true);
</script>

<!-- 2. Then the Google tag -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-XXXXXXXXXX"></script>
<script>
  gtag('js', new Date());
  gtag('config', 'G-XXXXXXXXXX');
</script>

When the banner records a choice, send all four signals every time. An update changes only the keys it names, so an “analytics only” update that leaves out the advertising signals keeps whatever they were before. If the visitor accepted everything earlier and now picks analytics only, the three advertising signals stay granted. Google’s setup guide uses the same update command for a change from granted to denied, with all four types in its withdrawal example (checked 2026-10-17).

// "Analytics only"
gtag('consent', 'update', {
  ad_storage: 'denied',
  ad_user_data: 'denied',
  ad_personalization: 'denied',
  analytics_storage: 'granted'
});

// "Accept all"
gtag('consent', 'update', {
  ad_storage: 'granted',
  ad_user_data: 'granted',
  ad_personalization: 'granted',
  analytics_storage: 'granted'
});

// "Reject" or a later withdrawal
gtag('consent', 'update', {
  ad_storage: 'denied',
  ad_user_data: 'denied',
  ad_personalization: 'denied',
  analytics_storage: 'denied'
});

wait_for_update gives the consent tool that many milliseconds to send the update before tags fire; Google’s example uses 500. It is a short bounded wait for a tool that loads asynchronously, not a wait for the visitor to decide. To scope a default to some places, add a region list to the default command. A default without region applies to every visitor not covered by a region-specific default.

In Google Tag Manager the same order uses the Consent Initialization trigger, which runs before every other trigger. Set the default there with a CMP template from the Community Template Gallery, or with a custom template that calls setDefaultConsentState, and send the visitor’s choice with updateConsentState. Each tag’s own consent requirements live under its Advanced Settings and in the Tags list’s consent overview. For Basic mode, that per-tag requirement is what keeps the tag from firing at all.

To confirm it, check three places. The Tag Assistant Consent tab shows the On-page Default and On-page Update columns for each consent event. The browser’s network panel shows the request itself. On a GA4 /g/collect hit, the gcs parameter carries ad_storage and analytics_storage, and gcd, which Google says is always sent, carries the wider consent state. Google warns these encodings “may be subject to change”, so read them as a confirmation next to Tag Assistant, not as a fixed table. Google Ads Conversion Diagnostics reports the modeling status. The Portuguese guide on validating Consent Mode v2 walks through the test matrix.

What we found on a live site (2026-10-13)

The client was a Brazilian sports site. Its front-end team reported that our GTM container sent an all-granted consent update even when a visitor refused tracking. They were right. The cause was a bridge tag we had published on 2026-09-01. At that point the site sent an all-denied default and had no banner, and the tag granted consent at Consent Initialization. Its notes said to retire it once a real banner existed. Nobody did.

We reproduced it with a headless probe that replayed the banner’s own callback against the live container. A load with no choice set our first-party cookies, fired the Meta and TikTok PageView, and sent GA4 hits with gcs=G111. The server container had a second leak. Its browser-event Meta, TikTok and Google Ads tags treated ad storage consent as optional, so our server subdomain set _fbp and _ttp on a no-choice load. We paused the bridge tag, made the server tags require ad storage consent, and published both.

The first check, about six minutes after the server publish, still saw _fbp and _ttp on 2 of 5 no-choice loads. About fifteen minutes after, 10 of 10 were clean. Our best guess is a server instance still serving the previous version for a few minutes, but we didn’t confirm which version answered each request. So check right after a server publish, and check again a little later before you call it done.

Then we clicked the real banner in headed Chrome, with a fresh browser context per stage:

Stage Our first-party cookies Meta and TikTok GA4 gcs
No choice, or “reject optional” None Nothing sent G100
Analytics only Set Nothing sent G101
Accept all Set PageView sent, _fbp and _ttp set G111
Reload after accepting Kept, banner stays closed Stored choice fires them again G111
Accept, then withdraw Journey and attribution cookies deleted No new _fbp or _ttp from our server Last hits G111, then no granted hit

The withdraw row looked like a failure at first. The hits around the withdrawal carried G111, but each one was the click itself (cta_click, scroll_depth), sent under the old state before the update applied. No granted hit came after it. The server subdomain set no _fbp or _ttp in any stage. We did not open the Tag Assistant or server Preview consoles in that run, because both need a logged-in Google identity in the automated browser. The wire, the server’s outgoing logs and the template tests covered the same layers.

How modeling fills the gap, and where it stops

The cookieless ping is an observation, not a recovered conversion. Two kinds of modeling use it. Behavioral modeling estimates metrics that depend on recognizing a returning user, such as users and sessions. Conversion and key-event modeling estimates the conversions and attribution that could not be observed.

In Google Ads, conversion modeling runs in both modes, with the account-specific model in Advanced. Google’s eligibility pages give click thresholds per country and domain grouping, and two of them disagree; the EU sales audit lays out both numbers.

In GA4, behavioral modeling needs Advanced mode, and Google publishes the prerequisites (checked 2026-10-17):

  • Consent Mode on every page, with Google tags loading before the consent dialog and in all cases, not only after consent.
  • At least 1,000 events per day with analytics_storage denied, for at least 7 days.
  • At least 1,000 daily users sending events with analytics_storage granted on at least 7 of the previous 28 days.

Meeting them does not guarantee eligibility, and Google says training can take more than 7 qualifying days. Modeled data appears from the date the property becomes eligible. If a property loses eligibility and regains it, estimates return only from the regained date, and earlier date ranges show as unavailable. A smaller site may never qualify.

The limits stay the same whichever mode you pick. Modeled numbers are estimates and move as the model moves, which makes them useful for trends and bidding direction but not for reconciliation against invoices. They cover Google products only. Meta and TikTok need their own consent handling, and their conversion APIs are delivery channels, not consent mechanisms; the Meta Conversions API guide covers that path. And no consent setting proves that a conversion was real. A consented purchase event can still be a duplicate, a test or a failed payment, which the Stripe conversion tracking guide handles with webhook validation.

Server-side routing is optional

Some teams send Google hits through a first-party server endpoint, such as a server-side Google Tag Manager container, so fewer of them are filtered on the way. That is an architecture choice, not a Consent Mode requirement. The browser still has to reach the endpoint, so the request can still be blocked, and the endpoint does not repair a cross-domain handoff.

What the server must not do is ignore the consent state it receives. On the client above, the fix for the _fbp leak was a server-side setting: each ad tag now requires ad_storage consent, read from the incoming GA4 hit, and skips the visitor otherwise. Hosting that container is covered in the server-side GTM guide.

If you are expanding into Europe and see paid orders missing from Google Ads, the EU tracking audit checks orders, consent states, event delivery and attribution in sequence.