What breaks when GPT's updateCorrelator stops working?

From the week of 7 December, updateCorrelator() does nothing. Pages that use it for roadblocks or competitive exclusions need Single Request Architecture first.

A two-colour risograph print of a rail yard seen from above, grey freight wagons standing apart on the side tracks and five coupled blue container wagons leaving together on the middle track.

Starting the week of 7 December 2026, calling googletag.pubads().updateCorrelator() has no effect. The ads keep loading. What can break is anything that relied on the call to group slots into one page view: a roadblock that should show all its creatives together, or two competitors kept apart by an exclusion label. The fix Google names is Single Request Architecture.

Google announced the deprecation in the GPT release notes for the week of 9 November. Three weeks is enough to find the call, decide what it was for and test the replacement, if you start this week. This post walks through all three.

What the correlator does, and what updateCorrelator() changed

Every ad request GPT sends carries a correlator. The GPT reference describes it as the same for all the ad requests coming from one page view, and unique across page views. Ad Manager uses it to know that the leaderboard request and the sidebar request belong to the same visit to the same page, which is what lets a roadblock or an exclusion work across slots.

updateCorrelator() changed that value by hand, which, in the reference's words, effectively starts a new page view. Sites used it in a few places: before refreshing every slot on a long article, between stories on an infinite scroll page, and on route changes in single-page apps where the browser never loads a new document.

GPT now does most of this itself. Since the week of 19 October it updates the page correlator on client-side navigations in single-page apps. The refresh() reference says a new correlator is generated for every refresh by default, unless you pass changeCorrelator: false. The 9 November note sums it up: GPT updates correlators across initial page loads, ad refreshes and client-side navigations, so the manual call has nothing left to do in those cases.

Where the old call still mattered: roadblocks and competitive exclusions

The case Google calls out is coordination. If you used updateCorrelator() to make a roadblock or a competitive exclusion apply to a fresh set of slots, the release note tells you to move to Single Request Architecture (SRA) by setting singleRequest in googletag.setConfig(). SRA works with GPT's long-lived pageview, which keeps a record of the ads currently on the page and, per the reference, has no expiration time.

Two Ad Manager rules explain why SRA is the answer and not just a recommendation.

Roadblocks first. The roadblocks help page says guaranteed roadblocks only work with GPT in single-request mode. A line item set to display "All" creatives is treated as "As many as possible" when GPT is not in single-request mode, because without SRA Ad Manager cannot be sure the later requests come from the same page. It serves the first creative and gives the rest priority on the requests that follow.

Competitive exclusions second. The Ad Manager help page on labels recommends one SRA request with all ad slots, because multi-request tags do not guarantee exclusions. Even with SRA, Google notes that a small share of visitors can see two labelled line items together, for example when the request lands on different data centers.

The help page on GPT client-side tokens adds a time limit. The token that correlates requests on a page expires after 10 seconds, after which a slot stops affecting creative selection for the others. If SRA is not possible, Google's fallback is to fully serialize requests, each one waiting for the previous slot's response, and it warns that this costs latency.

Old pattern and new pattern side by side

What the page did Before 7 December From the week of 7 December
updateCorrelator() before refreshing all slots New page view for the refreshed set No effect. refresh() already sends a new correlator by default
updateCorrelator() on a single-page app route change New page view after the route change No effect. GPT updates the correlator on client-side navigations
updateCorrelator() to regroup slots for a roadblock Roadblock could apply to the new set No effect. Needs SRA, with the roadblock slots in one request
Competitive exclusion labels on a multi-request page Not guaranteed Still not guaranteed. Needs SRA

How to find out whether your pages call it

Start with the code. Search the site repository, the ad wrapper and every tag in your tag manager container for updateCorrelator. Include the ad wrapper build and any infinite scroll plugin, since both often live outside the main repository.

Then check the live page, because the code you search is not always the code that runs. Open a page on your busiest template, open the browser console and run this before you scroll or click to another page:

// Log every updateCorrelator() call from now on, with the caller
const pa = googletag.pubads();
const original = pa.updateCorrelator.bind(pa);
pa.updateCorrelator = function () {
  console.trace('updateCorrelator() called');
  return original();
};

Scroll to the second article, click through a route change, wait for a refresh cycle. Each call prints a stack trace that points at the script making it. The snippet only catches calls made after you paste it, so a call during page load will not show; the code search covers that one.

Next, see whether the page already uses SRA. Open the Network panel, filter on gampad/ads and reload. The singleRequest reference says that with SRA on, all slots defined before a display() or refresh() call go out in one ad request, and with it off each slot is requested on its own, which is GPT's default. Five slots and five requests on load means SRA is off.

What to change before the week of 7 December

If the call only ran before refreshes or on route changes, delete it. GPT handles both, and the line becomes dead code that a future reader will copy.

If a roadblock or an exclusion label depends on it, turn on SRA and follow its rules:

  1. Set googletag.setConfig({ singleRequest: true }) before googletag.enableServices(). The reference says it must come first. The older enableSingleRequest() method is deprecated in favour of this setting.
  2. Define the slots that must be decided together, with their targeting and category exclusions, before the first display() call. The best practices guide is direct: only values configured before that point are included in the initial SRA request.
  3. Keep the roadblock's slots in one batch. Google's SRA batching sample warns that roadblocks are not guaranteed across multiple SRA batches, which matters when lazy loading or a header bidding wrapper refreshes slots in separate groups.
  4. Remove slots with googletag.destroySlots() when content leaves the page, as the client-side token help page advises, so an old ad does not keep influencing the next decision.

Test on one template first. SRA changes when and how many requests leave the browser, so the timing of your Prebid auction and your lazy loading thresholds can move with it. Our post on Prebid upgrades and bidder timeouts has a before and after method that works here too.

What to watch in Ad Manager after the switch

Pull the line items that use roadblock creatives or carry a competitive exclusion label, and compare their delivery for the two weeks before 7 December with the two weeks after. A roadblock set to "All" that suddenly delivers on far fewer page views is the first sign that its slots no longer share a request. For exclusions, the report will not show a clash; the advertiser will, so tell the sales team which pages changed and when.

Note the date your change went live. If both your release and Google's switch land in the same week, you will want to know which one moved the numbers.

A PubPilot Ad Manager alert can do that watching for you. Filter it on the roadblock line item's name, set it to fire on a percentage drop in impressions, and the drop reaches you by email, or in Slack on Plus and Pro, instead of through the advertiser.

Questions people ask

What did googletag.pubads().updateCorrelator() do?
It changed the correlator, the value GPT sends with every ad request so Ad Manager can tell which requests came from the same page view. A new correlator told the ad server that a new page view had started. Pages called it before loading a fresh set of ads, often to make a roadblock or a competitive exclusion apply to that set as a group.
Will my ads stop serving after 7 December if the page still calls updateCorrelator()?
No. Google says the call will have no effect, which means GPT ignores it and the ads load as before. What changes is whether Ad Manager treats the slots as one page. Roadblocks and competitive exclusions that relied on the call can stop holding if the page does not use Single Request Architecture.
Do I need Single Request Architecture if I sell no roadblocks?
Not for this change. If no line item uses roadblock creatives and no line item carries a competitive exclusion label, removing the updateCorrelator() call is enough. Google still recommends SRA for pages that use either feature, and it batches slots into fewer requests, so it is worth a test on its own merits.

Sources

More from the blog