Here's a riddle the advertising industry would rather you didn't solve. A privacy update was announced with real fanfare. It was supposed to shrink the amount of device data your browser gives away. And yet, several years on, trackers can pull a cleaner, more precise picture of your hardware than they ever could before. How does a privacy feature end up making fingerprinting easier?
The answer is User-Agent Client Hints, and it's the quiet story behind a lot of what tracks you in 2026. This article unpacks how a well-intentioned change became a structured data pipeline, what specifically leaks through it, why the privacy habits you trust don't catch it, and where you can actually intervene. None of it requires a computer science degree to follow — just a willingness to look at what the “fix” actually did.
A fix that solved the wrong problem
To see why Client Hints matters, you have to understand what came before it.
For decades, every page you opened received a User-Agent string from your browser — a single messy line of text announcing your browser, your operating system, and rough device details. It was sent automatically, to everyone, on every request. Data brokers loved it precisely because it was so chatty: a free passive signal they could fold into a fingerprint without lifting a finger.
Browser makers, with Google Chrome leading, identified this as a privacy problem and proposed a cure. They would freeze and reduce the User-Agent string, trimming the detail it broadcast by default. The pitch was clean: less automatic information, less passive fingerprinting. On its face, reasonable.
“A feature sold as anti-fingerprinting became a higher-quality fingerprinting input.”
But the detail didn't disappear. It was relocated. In place of the old broadcast, the industry rolled out User-Agent Client Hints (UA-CH) — a new framework for delivering the same kind of device information through a different, more deliberate channel. And that channel, researchers now confirm, hands certain data out more cleanly than the old string ever did. The problem the update addressed was how loudly your browser announced itself. The problem it created was how precisely a script could now ask.
How the “ask permission” model actually works
Client Hints was framed around a sensible-sounding idea: structured request instead of indiscriminate broadcast. Rather than your browser shouting everything to every server, a site now has to ask for the specifics it wants. In principle, that's an improvement. In practice, the asking has two tiers, and the gap between them is where the trouble lives.
Low Entropy hints are the harmless tier. These cover broad strokes — whether you're on a mobile device, your general browser brand. There's little here that singles you out, because millions of people share the same answers.
High Entropy hints are a different animal entirely. When a script runs the getHighEntropyValues() command, the browser quietly returns granular system details that, combined, make you far more distinguishable:
- CPU architecture — the kind of processor you're running, such as ARM versus x86.
- Device model — your specific physical model, which is especially identifying for Android and Windows users.
- Platform version — the exact, unredacted build number of your operating system.
- Bitness — whether your system is 64-bit or 32-bit.
Notice the word doing the heavy lifting: entropy. In fingerprinting, entropy is just a measure of how much a detail narrows you down. Your browser brand barely moves the needle. But your exact OS build, paired with your precise device model and processor architecture, can carve the crowd down to a sliver. Each High Entropy answer is another distinguishing feature stacked onto your profile.
The catch: the gate was left open to everyone
The intuitive assumption is that “ask permission” means you get asked. It doesn't. The permission model governs which scripts can request the data — and crucially, it didn't lock third-party advertising scripts out.
That single design choice is the whole ballgame. Independent researchers have observed that across a large share of top websites, hidden tracking and advertising scripts are actively calling the High Entropy API to pull hardware data. Not a fringe handful of shady sites — a common feature of the places people visit daily.
Compare the effort involved across the old world and the new. Under the User-Agent string, a tracker had to parse a sloppy text blob, guessing and pattern-matching to extract device details. Under Client Hints, it just runs a clean, standardized JavaScript command and receives a tidy, structured hardware profile in return. The web platform itself now does the hard part for the tracker. What used to be inference is now a direct, reliable readout.
From there, the math is quick. The harvested hardware profile gets fused with your IP address and screen resolution to produce a fingerprint distinctive enough to follow you from site to site — no cookie required, and therefore untouched by every cookie restriction you might rely on. The irony is sharp: a feature sold as anti-fingerprinting became a higher-quality fingerprinting input.
Why your privacy habits walk right past it
This is the part worth slowing down on, because the usual defensive playbook simply doesn't apply here — and understanding why tells you where the real fix has to live.
Run through the standard moves and watch each one fail:
- There's no prompt. You'd reasonably expect that handing your CPU architecture and device model to a third-party broker would trigger some kind of warning. It doesn't. The High Entropy request resolves silently in the background, with no pop-up, no notification, nothing you'd ever see.
- Incognito mode and Do Not Track are bypassed. These were built to govern stored tracking files and to signal a preference. But this extraction flows through a standardized browser API, not a cookie or a saved tracker. A private window still runs the same JavaScript; the API still answers. There's no stored artifact for incognito to withhold.
- Legacy ad blockers don't flag it. Tools built primarily to block known third-party cookies see the Client Hints API doing exactly what browser APIs are designed to do — responding to a script's request. To that kind of blocker, a getHighEntropyValues() call looks like ordinary, legitimate browser machinery, so it waves the data through.
The common thread is important. Every one of these defenses was designed for the previous generation of tracking — stored files, broadcast headers, identifiable cookies. Client Hints sidesteps all of it by operating as a sanctioned feature of the platform itself. You can't delete your way out of a thing that was never saved, and you can't decline a request you're never shown. So the only place left to intervene is earlier: at the script that makes the call and the connection that carries the result away.
Where the extraction can actually be stopped
If the data leaks through scripts and APIs rather than cookies, then the defense has to operate at that level too — not by tidying up afterward, but by stopping the request from completing in the first place. That's the logic behind how Total Adblock approaches this.
Instead of waiting for a stored tracker to delete, Total Adblock uses network-level filtering and script interception, examining the requests a page makes as it loads. It targets two specific points in the chain:
- The scripts that ask. It identifies the third-party domains, telemetry servers, and analytics scripts that try to fire getHighEntropyValues() or request the Sec-CH-UA family of HTTP headers — and blocks them from running. A script that never executes can't query your hardware.
- The connections that carry it home. Even if a hint were gathered, the data is worthless to a broker until it reaches the broker's server. By severing connections to known telemetry endpoints, Total Adblock keeps any collected profile trapped on your own device.
The reason this works where the older defenses don't is that it doesn't depend on the data being a cookie, or on a consent prompt appearing, or on a blocklist recognizing a stored file. It acts on the mechanism the leak actually uses: a script calling an API and shipping the answer outward. Cut the script, cut the connection, and the structured pipeline has nothing to deliver — your CPU architecture, device model, OS build, and bitness stay where they belong, on your machine. As a side benefit, blocking those background scripts and requests trims overhead the legitimate page never needed.
The takeaway worth keeping
The Client Hints story is a useful reminder that “privacy update” describes an intention, not a guarantee. Freezing the User-Agent string was real, and the High Entropy API is real — but the second quietly handed trackers a cleaner channel than the first ever closed. The result, seen widely across the modern web, is a structured way to read your hardware that Incognito, Do Not Track, and cookie-focused blockers were simply never built to catch.
So here's the concrete next step. If your privacy strategy still rests on clearing cookies and trusting private browsing, it has a blind spot exactly the size of this API. Closing it means moving your defense upstream — to the scripts that make the call and the endpoints that receive the answer. Let Total Adblock intercept those requests before your system specs ever leave the device, and turn a feature the industry repurposed against you back into a non-event.
