Consent banners and what your cookie choices reveal
The banner that’s supposed to protect you also profiles you
Every site you visit in the EU, the UK, California, and a growing list of other jurisdictions now greets you with a pop-up asking permission before it tracks you. That’s the point of GDPR, the ePrivacy Directive, and CCPA/CPRA: make tracking opt-in instead of silent. The banner is the visible proof that a law is being followed. The obligation kicks in before a single tracking cookie gets set, and it applies broadly: e-commerce checkouts, news sites, SaaS dashboards, forums, anything running an ad tag or an analytics snippet that a visitor from a covered jurisdiction might load. That scope is why the banner has become close to universal furniture on the web rather than a niche compliance feature confined to a handful of sites.
Here’s the part most people miss. The banner itself is a tracking event. Before you’ve made any choice about cookies, a script has already loaded, rendered the interface, and started listening. Whatever you click next, accept, reject, or close the tab, gets written somewhere and often sent somewhere. The mechanism built to reduce tracking runs on the same infrastructure as the tracking it’s regulating.
This matters beyond privacy trivia. If you run more than one browser profile, whether that’s a handful of test accounts or a real multi-accounting operation using tools like Multilogin, GoLogin, Kameleo, AdsPower, or Dolphin Anty, the consent banner is one more surface where your profiles can look either convincingly independent or suspiciously identical. Fingerprint spoofing gets a lot of attention: canvas noise, font lists, screen resolution, WebGL parameters. The consent interaction sits right next to all of that and almost nobody accounts for it. Whether you’re running ten profiles or five hundred, the same mechanism runs against each one individually, and each one leaves its own trail. This piece walks through what actually happens technically when a banner loads and you click something, who ends up holding that data, and what it means for anyone trying to keep browser profiles looking distinct from each other.
What a consent management platform actually does
The pop-up you see is almost never built by the site you’re on. It’s served by a consent management platform, or CMP, a third-party vendor the site embedded with a script tag. OneTrust, Cookiebot, TrustArc, Quantcast Choice, and Didomi are the names you’ll see most, running on a large share of sites that display these banners at all.
Before it even decides what to show you, the script typically checks your approximate location through IP geolocation, because GDPR’s opt-in requirement and CCPA’s opt-out requirement don’t apply the same way everywhere. A visitor detected in Ohio might see a much lighter banner, or none at all, than a visitor detected in Frankfurt, even though both are loading the identical page from the identical server. That geo-check is itself a small piece of data processing happening before you’ve agreed to anything, since estimating your rough location from your IP address counts as processing personal data under most of the same laws the banner exists to satisfy.
The CMP script does three things. It renders the banner UI. It holds back other scripts on the page, analytics, ad tags, session recording tools, until you make a choice, or lets them fire immediately if the site treats consent as implied. And it records your decision in a format other systems can read later. The “purposes” behind that recording are standardized categories rather than plain English: things like storing and accessing information on a device, using limited data to select advertising, measuring ad and content performance, and developing and improving products. A typical vendor list attached to those purposes runs into the hundreds of ad-tech companies the site has authorized, most of which never surface in the banner’s default view and only appear if you drill into “manage preferences” and scroll through a list that can run past a hundred names, each with its own toggle.
That last part runs on a standard. The IAB Europe Transparency and Consent Framework, known as TCF, defines how a consent decision gets encoded into a string that gets passed along to every ad vendor bidding on that page. Google has its own related system called Consent Mode. Either way, the CMP is a separate piece of infrastructure with its own storage, its own logging, and often its own subdomain or CDN endpoint that your browser talks to directly.
That separation is worth remembering. When you interact with a banner, you’re not just telling the site what you want. You’re generating a record inside a vendor’s system that operates across a huge number of unrelated websites.
The “reject all” click isn’t the end of the transaction
Clicking reject feels like it should end the conversation. Mechanically, it starts a new one. The CMP still has to remember that a decision happened, otherwise the banner reappears on every page load, which would make the site unusable. Remembering requires storage, usually a first-party cookie, sometimes a localStorage entry, occasionally both.
That storage write holds an identifier, a timestamp, and the encoded preferences themselves: which vendors you allowed, which purposes you approved, and which ones you declined. This happens no matter which button you press. Accept all writes a record. Reject all writes a record. Clicking through “manage preferences” and toggling twelve vendors individually writes a more detailed record than either of the blanket options.
Picture a shopping site that lists eleven ad-tech vendors under four purposes. A visitor who declines all four purposes but leaves two “legitimate interest” toggles enabled writes a very specific record: two purposes granted under one legal basis, four declined under another, out of a set of possible combinations that runs into the thousands once you multiply purposes by legal basis by individual vendor overrides. That level of granularity is rare among real visitors, which is exactly why it stands out when it appears, whether the visitor is a genuinely careful human or a script working through a fixed configuration.
The one path that avoids writing anything is closing the tab before choosing, and even that’s logged in some implementations as “no decision,” which some CMPs treat as a rejection and others treat as consent by default, depending on jurisdiction settings configured by the site. Nested banners complicate this further: an embedded video player or a third-party comment widget can run its own separate CMP inside the page, meaning a single page load can produce two or three independent consent transactions instead of one, each with its own storage write and its own vendor list.
The practical upshot: there is no interaction with a consent banner that leaves zero trace. The only variable is how detailed the trace is. A blanket accept or reject writes a compact record. Granular vendor-by-vendor choices write something closer to a fingerprint of your actual preferences, which, because most visitors never touch the granular options, is itself a distinguishing signal.
The consent string is a fingerprint with a legal alibi
The TCF consent string, often called a TC string, is worth looking at directly because it shows how much detail lives inside what looks like a simple yes or no. Pull one out of your own browser and decode it, and the shape is fairly readable: a CMP ID and version number identifying which vendor served the banner and which release of their script; a “created” and “last updated” timestamp down to the second; a range encoding marking which of the few hundred vendors in the Global Vendor List you consented to, typically stored as ranges rather than a full enumerated list, because most visitors accept or decline blocks of vendors at once rather than picking individually; consent and legitimate-interest flags for each of the standard purposes; any special features enabled, most commonly precise geolocation; and, increasingly, publisher-specific restrictions the site has layered over the default framework, overriding a vendor’s default purpose for that property specifically.
That string gets attached to real-time bidding requests sent to ad exchanges for every ad slot on the page. It’s designed to be machine-readable and interoperable across vendors, which means it’s also extremely specific. Two visitors who both clicked “accept all” still produce different strings if they hit different CMP versions, at different times, on sites with different vendor lists configured.
The string isn’t static once written, either. Many implementations regenerate part of it on subsequent visits, updating the “last updated” field even if none of your actual choices changed, because the framework was designed to prove a decision is current, not just that one was made at some point in the past. That means the string sitting in your storage today may carry a different timestamp than the one an ad exchange logged during the bidding request the first time you visited, even though nothing about your underlying consent has changed in between.
None of this is secret or hidden. The IAB publishes public tools to decode a TC string, and you can pull one out of your own browser’s storage after interacting with a banner and read exactly what it says about you. That transparency is part of the legal design, the framework exists so regulators and auditors can verify consent was actually captured. But transparency to auditors doesn’t mean the string stops functioning as an identifier when it travels through an ad exchange’s systems alongside your IP address and device signals.
Click speed, cursor path, and the behavioral layer
Consent logging isn’t limited to what button you pressed. Many of the same pages running a CMP also run separate bot-detection or ad-fraud scripts, and those scripts don’t care about your legal preferences, they care about how you moved. Time from page load to first interaction, cursor path toward the button, whether you scrolled before deciding, whether you hovered over “manage preferences” before clicking “accept all” anyway.
This is standard behavioral telemetry, the same category of signal that login forms use to watch typing cadence between keystrokes. Humans are irregular. A real visitor’s time to first click on a banner isn’t a fixed number; it ranges from under a second, someone who has seen a hundred of these banners and clicks reflexively without reading, to well over a minute, someone who gets distracted mid-page-load and comes back to a page they’d half forgotten was waiting for input. A scripted interaction, whether that’s a test suite, a scraper, or a batch automation tool driving several browser profiles through onboarding, tends to click at a much more consistent delay after the page finishes rendering, at coordinates that don’t vary the way a human hand does. Cursor movement is its own tell: a real hand moves toward a button along a slightly curved, jittery path with small corrections near the end, while some automation frameworks move the cursor in a straight line at constant velocity, or skip the movement entirely and dispatch a synthetic click event directly at the element’s coordinates.
None of this proves anything on its own. Plenty of real humans have consistent habits, and plenty of scripts add randomized delays specifically because this pattern is well known. But it’s one more input into whatever risk score a site or ad vendor is computing, and it’s an input that lives at the exact layer most anti-detect tooling ignores, because anti-detect browsers are built to spoof static device properties, not to simulate the rhythm of a person deciding what to click.
Why the same person’s cookie choices differ across ten profiles
If you’re running isolated browser profiles, whether through separate browser installs, containers, or a dedicated multi-accounting tool, each profile has its own cookie jar and its own localStorage. That means each profile hits the consent banner fresh and has to make its own decision, independent of what any other profile did on the same site.
That’s actually the correct baseline. Picture the same site being visited independently by ten real people over the course of a day. A few click accept immediately because they don’t care and just want the pop-up gone. A couple read enough to click reject specifically, maybe because they’ve had a bad experience with targeted ads before. One or two open “manage preferences,” scroll past most of it, and toggle off just the vendors whose names they don’t recognize. A couple never make a decision at all because they open the page, don’t find what they wanted, and leave before the banner gets touched. No two of those ten interactions look alike in timing, choice, or depth of engagement with the banner. Real human traffic to a site is a spread, not a single repeated pattern.
Ten profiles that all click “accept all” at a near-identical delay after page load are not behaving like ten independent people. The tell isn’t the choice itself, plenty of legitimate batch processes reasonably default to reject-all for compliance simplicity, it’s the clustering: if ten profiles land within a narrow band of each other on timing, choice, and depth of interaction, when the natural range across real independent visitors is wide, that clustering is the anomaly, not any single data point inside it. That doesn’t automatically flag anything on its own, but it’s a correlated signal sitting alongside whatever fingerprint properties those profiles are also sharing or failing to vary. If a set of profiles otherwise looks distinct, different screen sizes, different fonts, different time zones, but all converge on the exact same consent-click timing, that convergence is itself information. It suggests a shared driver behind supposedly independent browser instances, which is exactly the kind of correlation that anti-fingerprinting setups exist to avoid creating in the first place.
Who actually holds this data: OneTrust, Cookiebot, TrustArc, Quantcast
It’s worth being specific about scale here, because “a third party has this data” undersells how concentrated the consent-logging market is. OneTrust, Cookiebot, TrustArc, and Quantcast Choice between them run the consent banner on a very large share of the sites that show one at all. When you interact with a banner on one site running OneTrust, and a different banner on an unrelated site also running OneTrust, you’re generating records inside the same vendor’s infrastructure, not two isolated site-level logs.
The consent cookie itself is normally scoped to the individual site’s domain, so it doesn’t silently follow you across properties the way a third-party ad cookie historically did. What does travel across sites is the pattern: the CMP vendor’s backend receives a log line from every site running its script, request logs land in shared infrastructure even though each domain’s stored cookie stays local to that domain, and request-level identifiers like IP address, TLS fingerprint, and device signals sit right next to those log lines regardless of which site sent them. The site-level isolation is real at the cookie-jar level; it doesn’t extend to the vendor’s own backend.
This is structurally similar to how a general browser fingerprint (canvas rendering, installed fonts, WebGL parameters) travels across sites through shared ad-tech and analytics vendors, rather than staying contained to one property. Consent behavior follows the same pattern: it’s not a per-site record, it’s a cross-site one, held by a small number of vendors who serve a large fraction of the web.
That concentration cuts both ways. It means a single CMP vendor has visibility across huge swaths of your (or your profiles’) browsing, which is a meaningful privacy fact on its own. It also means the behavioral signal, click timing, decision path, vendor toggles chosen, gets compared against a much larger baseline of “normal” human interaction than any single site could build on its own. A pattern that looks unremarkable against one site’s traffic can look mechanical against a CMP vendor’s pooled dataset spanning thousands of sites.
Google’s Consent Mode and modeled data
Google runs a parallel system called Consent Mode, currently in its second version, which most sites using Google Analytics or Google Ads tags have implemented, in some regions because Google requires it for continued ad personalization features. Consent Mode changes how Google’s own tags behave based on the consent signal, rather than a fully separate CMP.
There are two flavors of how strictly this gets applied, depending on the site’s implementation. The “basic” configuration withholds Google’s tags entirely until a visitor makes a decision, functioning much like any other CMP-gated script. The “advanced” configuration loads the tags immediately but adjusts their behavior based on the consent signal once it arrives, and it’s this version where the cookieless-ping behavior matters most.
When a visitor declines analytics or advertising cookies under the advanced setup, the Google tags don’t simply stop firing. They switch into what Google calls a cookieless ping mode, sending a reduced signal that doesn’t carry a persistent identifier but still tells Google that a page view happened, roughly when, and with what broad context. Google then uses statistical modeling, built from the behavior of visitors who did consent on the same site, to estimate the missing data for the ones who didn’t. In practice this means conversion modeling fills the gap using patterns from consented visitors with similar characteristics, device type, browser, rough geography, time of visit, to estimate how many of the non-consenting visits likely also converted, without ever attaching an identifier to any individual one of them.
The practical point for anyone thinking rejecting cookies means opting out of data collection entirely: it doesn’t. It changes the shape and granularity of what’s collected and how it’s attributed, but a rejected-consent visit still contributes an event, still gets counted, and still gets folded into aggregate modeling. “I clicked reject” is a real legal choice with real limits on what can be stored and for what purpose, but it isn’t a switch that makes a visit invisible to the site’s analytics stack.
Consent survives longer than you think
The decision you make on a banner doesn’t expire quickly. CMPs generally store the consent record for an extended period, commonly somewhere in the range of six months to a year before the banner is set to reappear and ask again, though the exact duration is configured per site and varies by vendor and jurisdiction requirements. Until that expiry, the site treats your earlier decision as still valid and won’t ask again.
Some browsers additionally cap how long they’ll honor any cookie regardless of the expiry the site requested. Safari’s Intelligent Tracking Prevention, for instance, has historically capped script-writable cookies at a matter of days in many scenarios, which means a consent cookie set through JavaScript rather than delivered via an HTTP response header can get evicted well before the compliance policy’s stated retention window, forcing the banner to reappear far sooner on that browser than the site intended. That mismatch between the retention period a site configures and the retention period a browser actually enforces is one more source of inconsistency between profiles that ought to be behaving identically but aren’t, depending purely on which browser engine each one runs.
For a normal user this is a convenience feature, nobody wants to click through a cookie banner every single visit. For a browser profile that’s supposed to represent a fresh, independent identity, it means a single early interaction with a banner locks in a stored decision that will keep showing up in that profile’s storage for months, as a consistent data point that any script reading localStorage or cookies can find.
This also means consent state is one more thing that separates a genuinely fresh profile from one that’s been reused or cloned from an earlier session. A profile spun up minutes ago with no banner interaction yet looks different from one carrying a nine-month-old consent cookie, and that difference is visible to anything with access to browser storage, not just to the CMP itself.
What clearing cookies does and doesn’t undo
Clearing a browser’s cookies wipes the local consent record, and the banner will reappear the next time that profile visits the site, because as far as local storage is concerned, no decision was ever made. That’s real and it does reset the client-side state.
What it doesn’t touch is the server-side event that was already logged when the original decision happened. Say a profile visits a site, clicks reject, and the CMP logs that decision tied to an IP address and a fingerprint hash built from a couple dozen signals: user agent string, screen resolution, installed font list, canvas rendering hash, WebGL renderer string, timezone, and language settings. Three days later, cookies get cleared and the same profile, same IP, same couple dozen signals unless something in the underlying spoofing configuration was deliberately rotated, visits again and clicks accept this time. A fingerprinting system built to link sessions doesn’t need the cookie to notice that the incoming request looks like the same device making a different choice than it made three days earlier.
The CMP or the ad vendors it forwarded the TC string to already recorded that a decision occurred, tied to whatever identifiers were active at that moment. Clearing cookies doesn’t reach into that vendor’s server and delete the row. If the underlying fingerprint hasn’t meaningfully changed between the old session and the new one, cleared cookies or not, a new consent decision from the “same” device can still be probabilistically linked back to the earlier one through pattern matching on the fingerprint, timing behavior, and other signals that live outside the cookie jar entirely. Cookie clearing resets what the browser remembers locally. It does nothing to the graph a server already built from the last visit, and that graph is exactly what fingerprinting is designed to reconstruct even when cookies are gone.
Multi-accounting and the consistency problem
This is where the general mechanism connects directly to anti-detect browser work. These tools exist to make each profile present a distinct, internally consistent device fingerprint, spoofing canvas output, adjusting WebGL parameters, rotating fonts and screen properties, matching time zone to the assigned proxy’s geography, and so on. That’s real engineering and it addresses a real detection vector.
No anti-detect browser, regardless of how thorough its spoofing is, makes an account undetectable or a ban impossible. That’s true for the fingerprint layer, and it’s equally true for the consent layer, which most spoofing tooling doesn’t touch at all because it’s built to fake static device properties, not to simulate how a person decides what to click on a pop-up.
Picture a batch of fifty profiles, each with a unique canvas hash, a unique font fingerprint, and a proxy IP geolocated to match its assigned timezone. If all fifty run through onboarding using the same automation script, and that script clicks “reject all” at exactly the same delay after the DOM finishes loading on every single one, the fingerprint layer says fifty different devices while the behavioral layer says one script. A batch of profiles that nails every canvas and font detail but always lands on the consent banner with the same click timing, always picks the same button, or always disables the exact same set of vendors in the exact same order, has reintroduced a stable signature at a layer nobody was watching. Platforms and the ad-tech vendors sitting on their pages don’t need a perfect signal to raise suspicion, they need correlated ones. Consent interaction is one more axis that can correlate profiles which are supposed to look unrelated, sitting quietly next to the fingerprint work that gets all the attention.
What you can actually observe in a browser profile
You don’t need specialized tooling to see what a consent banner writes. Open the browser’s developer tools, go to the Application tab (or Storage in Firefox), and after interacting with a banner, look at the cookies, localStorage, and IndexedDB entries the CMP script wrote. Most implementations store a readable JSON blob or an encoded TC string alongside it, usually under a key or cookie name that embeds the vendor’s own branding somewhere in the string.
Decode what you find and the structure is fairly consistent across vendors: a consent identifier, a “created” timestamp and a “last updated” timestamp, an array of purpose flags, something like true or false for each of the standard purposes, a set of vendor ranges indicating which of the hundreds of registered ad-tech companies were included, and often a separate array for “legitimate interest” flags distinct from consent flags, since the two legal bases get tracked independently under the framework.
The IAB publishes public decoders for the standard TC string format, so you can take what your profile stored, decode it, and see exactly which vendors and purposes it represents, the CMP version, and the timestamps involved. Comparing what gets written after clicking “accept all” versus “reject all” versus closing the banner without deciding shows you directly how differently sized and how differently timestamped those records are. An “accept all” record on a site with three hundred registered vendors will encode most of that vendor list as consented ranges; a “reject all” record on the same site encodes almost none of it, but still carries the same identifier, timestamp, and CMP version fields, because the framework requires proof that a decision was made even when the decision was to decline everything.
This is useful for understanding what a given site’s consent stack actually captures and retains, which matters if you’re trying to reason about what data exists about a browsing session after the fact. It’s descriptive information about how the mechanism works, not a method for defeating detection on any platform, and it doesn’t change what a CMP vendor already holds server-side about a prior interaction.
Mistakes that make consent handling stand out
A few patterns show up repeatedly when consent handling gets treated as an afterthought rather than part of the profile design. Automation that dismisses the banner by directly manipulating the DOM, hiding the element with injected CSS or removing it with a script, rather than actually clicking the button, skips the interaction events the CMP’s own listeners expect to fire. That absence can be its own signal to anything watching for normal event sequences on the page.
Batches of profiles that always reject everything, because a granular reject flow is more code to write and maintain than a single “reject all” button, produce a population that never shows the varied, sometimes-accept-sometimes-partial pattern real visitors do. Fixed-delay automation, where every profile clicks the banner exactly two seconds after page load because that’s what the script sleeps for, produces a timing signature that’s trivially distinguishable from the spread you’d see in real human reaction times.
Reusing storage across profiles as a shortcut is another common one: copying a warmed-up profile’s localStorage or cookie jar into a fresh profile to skip the onboarding banner entirely saves a step, but it also hands the new profile an identical consent identifier, an identical vendor list, and a timestamp that predates the new profile’s own account creation date by however long has passed since the original run. Anything cross-referencing consent timestamps against account creation timestamps gets a mismatch for free.
And headless or automation-flagged browser instances carry their own separate tells that some bot-detection scripts read directly, independent of anything consent-related, meaning a profile can fail at that layer regardless of how well the consent interaction is handled. None of these are exotic failure modes. They’re the predictable result of treating the consent banner as a UI obstacle to clear rather than as a behavior that gets watched the same way everything else on the page does.
What to actually do on Monday
Treat the consent banner as part of a profile’s behavioral surface, not a UI step to script past as fast as possible. If a batch of profiles is going to interact with the same site, vary the timing and, where it’s reasonable, vary the choice itself, the way an actual spread of human visitors would, rather than hardcoding one path across every profile in the batch. That means building in a real distribution of delays rather than a single sleep value, occasionally routing a fraction of profiles through the granular “manage preferences” flow instead of always hitting the blanket buttons, and never copying one profile’s consent storage into another as a shortcut.
Understand what actually happens to the data regardless of which button gets clicked: a record gets written locally and, in most implementations, forwarded to third-party vendor infrastructure that operates across a large share of the web. Rejecting cookies limits what can be stored for advertising and analytics purposes under the relevant law, it doesn’t make a visit invisible, and it doesn’t stop a fingerprint-based signal from being collected alongside it.
No combination of settings, anti-detect browser or otherwise, makes a profile undetectable or removes the possibility of an account getting flagged or banned. That’s true of canvas spoofing, it’s true of proxy selection, and it’s true of consent handling. Budget for account loss as an ordinary cost of running multiple profiles, not as evidence that something was misconfigured. And if you’re evaluating anti-detect tooling, it’s worth checking whether it does anything at all with interaction behavior, click timing, decision variance, or whether it stops at spoofing static device properties and leaves the behavioral layer, including how a profile handles a consent banner, exactly as scripted and exactly as repeatable as whatever automation is driving it.
If you want the hands-on side of this, how specific anti-detect browsers actually hold up when tested rather than just described, that’s the kind of thing we run and film for the channel. Check out Anti-Detect Review for the rest of the testing.
Get new guides and videos first — join the Telegram channel.