Skip to content
AdminKit

What are User-Agent Client Hints, and why is the User-Agent string shrinking?

AdminKit explains why the User-Agent header is shrinking: for decades, one freely-readable User-Agent string carried a browser's name, version, engine and OS. Chromium-based browsers now send a shorter, more generic default string and move the detailed information behind an opt-in mechanism, User-Agent Client Hints, that a server must explicitly request via separate Sec-CH-UA headers.

By AdminKit team, Netbase JSC · Updated

Key takeaways

  • Chromium browsers (Chrome, Edge, Opera and others) now send a reduced User-Agent string: the major version is real, but minor version numbers read 0.0.0, and the OS version and Android device model are fixed placeholder values.
  • The detail moved into User-Agent Client Hints, separate Sec-CH-UA-* request headers. Three low-entropy hints are sent by default; the rest only after a server asks with Accept-CH.
  • Accept-CH only works over HTTPS and only for the origin that sent it.
  • Firefox and Safari don’t send these headers, so any server that reads them still needs a fallback.

Why did the User-Agent string need replacing?

The User-Agent header, defined by RFC 9110 §10.1.5, lets a client identify the software making a request — in practice, a long string packed with the browser’s name and version, its rendering engine, and the operating system and version it runs on. AdminKit’s user agent tool parses exactly this string and shows what it reveals about your own current connection. Every server you ever requested a page from received the full string, in full detail, on every single request — nothing about reading it required any special permission or opt-in.

That convenience came at a cost the string’s original design never accounted for: a sufficiently detailed, always-present string is a passive fingerprinting signal, read silently by any server without the visitor ever knowing or agreeing to share that level of device detail. Google’s own documentation on User-Agent Reduction names this directly — “the granularity and abundance of detail can lead to user identification,” and its default availability on every request “can lead to covert tracking.”

What changed in the reduced User-Agent string?

Chromium-based browsers (Chrome, Edge and others) now send a deliberately generalized User-Agent string by default: browser brand, a major version number, broad device category (mobile vs. desktop) and platform name stay accurate, while precise OS build numbers, device model and minor browser version get reduced to fixed, generic values instead of the real figure. Nothing about RFC 9110 required this reduction — it’s a browser-vendor privacy decision layered on top of a header the RFC still defines the same way.

The Chromium project’s User-Agent Reduction page publishes the exact format and sample strings. Here is its Android phone example before and after reduction:

before:  Mozilla/5.0 (Linux; Android 9; SM-A205U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.1234.56 Mobile Safari/537.36
after:   Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.0.0 Mobile Safari/537.36

The same page maps each reduced token to the client hint that now carries the real value:

Token in the stringAfter reductionWhere the real value lives now
Minor version (MINOR.BUILD.PATCH)Always 0.0.0Sec-CH-UA-Full-Version-List
Android versionAlways 10Sec-CH-UA-Platform-Version
Android device modelAlways KSec-CH-UA-Model
Desktop platform and OS versionOne fixed value per platform, e.g. Windows NT 10.0; Win64; x64Sec-CH-UA-Platform and Sec-CH-UA-Platform-Version
CPU detailsFixed with the platform valueSec-CH-UA-Arch, Sec-CH-UA-Bitness, Sec-CH-UA-WoW64

The page says these platform strings are literal values that “will not update even if a user is on an updated operating system or device”. Chromium rolled the change out in stages. Chrome 101 began zeroing the minor version, Chrome 107 began rolling out the reduced desktop string, and Chrome 110 the reduced Android string. With Chrome 113 the opt-out trial ended and all page loads received the reduced string. The reduction covers Windows, macOS, Linux, ChromeOS and Chrome on Android; at the time the page was written Chromium had no plans for iOS or Android WebView.

Which hints are sent by default, and which must be requested?

In place of the detail that’s now missing by default, the WICG’s User-Agent Client Hints specification defines a set of separate request headers — Sec-CH-UA, Sec-CH-UA-Mobile, Sec-CH-UA-Platform, and more — that a server has to explicitly ask for before receiving. The spec states its own goal plainly: to let “user agents be a bit more aggressive about removing entropy from the User-Agent string generally by giving servers that really need some specific details about the client the ability to opt-into receiving them.” Detail isn’t gone; it’s moved from “sent to everyone automatically” to “sent only to a server that asked.”

Per MDN’s Client Hints documentation, these hints split into two tiers:

  • Low-entropy hints — Sec-CH-UA, Sec-CH-UA-Mobile, Sec-CH-UA-Platform (and the unrelated Save-Data hint) — carry little enough identifying detail on their own that browsers send them by default, the same way the reduced User-Agent string is sent by default.
  • High-entropy hints — Sec-CH-UA-Model, Sec-CH-UA-Platform-Version, Sec-CH-UA-Full-Version-List and others — carry more identifying detail and are withheld until a server specifically asks for them.
HintTierWhat it carries
Sec-CH-UALow, sent by defaultBrand list with major versions
Sec-CH-UA-MobileLow, sent by default?1 on a mobile device, ?0 otherwise
Sec-CH-UA-PlatformLow, sent by defaultPlatform name, such as "Android" or "Windows"
Sec-CH-UA-Platform-VersionHigh, on requestThe real OS version
Sec-CH-UA-ModelHigh, on requestThe device model
Sec-CH-UA-Full-Version-ListHigh, on requestFull version for each brand

How does a server opt in with Accept-CH?

A server asks by sending an Accept-CH response header listing the hints it wants:

Accept-CH: Sec-CH-UA-Model, Sec-CH-UA-Platform-Version

The browser then includes those specific headers on its subsequent requests to that same origin. A server that never sends Accept-CH simply never receives the high-entropy hints — it only ever sees the low-entropy defaults, plus whatever the now-generalized User-Agent string still carries.

A full exchange on an Android phone looks like this (illustrative values, based on MDN’s examples; www.example.com is a placeholder):

GET / HTTP/1.1
Host: www.example.com
Sec-CH-UA: "Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"
Sec-CH-UA-Mobile: ?1
Sec-CH-UA-Platform: "Android"

HTTP/1.1 200 OK
Accept-CH: Sec-CH-UA-Model, Sec-CH-UA-Platform-Version
Vary: Sec-CH-UA-Model

GET /next-page HTTP/1.1
Host: www.example.com
Sec-CH-UA: "Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"
Sec-CH-UA-Mobile: ?1
Sec-CH-UA-Platform: "Android"
Sec-CH-UA-Model: "Pixel 9"
Sec-CH-UA-Platform-Version: "16.0.0"

RFC 8942, the experimental RFC that defines Accept-CH, sets three limits worth knowing. The opt-in must be ignored if it arrives over plain HTTP. It is bound to the origin that sent it, so https://www.example.com does not opt in https://shop.example.com or a third-party script’s origin. And it lasts for the browser session, so the first request to your origin in a new session carries only the low-entropy defaults. If a page truly cannot render correctly without one, MDN describes Critical-CH: the browser retries the request with the hint attached instead of rendering the first response. Hints that change a response also belong in Vary, so caches keep the variants apart.

Why does Sec-CH-UA contain a brand that doesn’t exist?

Look closely at the Sec-CH-UA value above and one entry, "Not A(Brand", names no real browser. MDN’s Sec-CH-UA reference calls it an intentionally incorrect brand that “may appear in any position and have different text”. The WICG specification calls the technique “GREASE”: it keeps servers from hard-coding exact header strings, so new browsers aren’t locked out by code that only recognises today’s values. The practical rules follow from that: parse the header as a list, look for the brand you care about, ignore the rest, and never compare the whole header against a fixed string. The specification also advises treating the brand list as a unit for analytics, because a less common browser may list a popular brand too.

How do you read client hints from JavaScript?

The same data is available to scripts through navigator.userAgentData, defined in the WICG specification. The low-entropy values are plain properties; high-entropy values come from an asynchronous call that the browser may decline:

// Only defined in browsers that implement UA Client Hints, in secure contexts.
if (navigator.userAgentData) {
  console.log(navigator.userAgentData.brands);   // [{ brand, version }, ...]
  console.log(navigator.userAgentData.mobile);   // true or false
  navigator.userAgentData
    .getHighEntropyValues(['model', 'platformVersion'])
    .then(values => console.log(values.model, values.platformVersion));
}

The if guard matters. MDN describes User-Agent Client Hints as an alternative for Blink-based browsers (Chromium, Edge, Brave, Vivaldi and others), so Firefox and Safari visitors have no navigator.userAgentData and send no Sec-CH-UA headers. Code that relies on hints has to fall back to the User-Agent string, which those browsers still send in full form.

Should a site rely on client hints at all?

Usually less than people expect. MDN’s guide to browser detection using the user agent says client hints beat sniffing the User-Agent string for Blink browsers, because they are spoofed less often and arrive as small fields that are easier to parse. It still calls changing site behaviour based on them “a bad idea” and points to feature detection and progressive enhancement instead: check whether the browser supports an API, or use CSS media queries for layout, rather than guessing from the browser’s name. Hints are also self-reported, just like the User-Agent string, so they are no more proof of identity than the header they replace. The use cases the WICG specification lists are narrower: browser market-share analytics, and offering the right binary download for an operating system and CPU architecture (32 vs 64 bit, ARM vs Intel), among others.

What does this mean if you’re reading request headers today?

If you’re inspecting what a visitor’s browser actually sends — the same exercise behind what a User-Agent string reveals and verifying a crawler’s User-Agent claim with reverse DNS — a modern Chromium User-Agent string alone will tell you noticeably less than it used to about the exact OS build or device model, by design. If your own site or service genuinely depends on that level of detail (rather than just logging or analytics curiosity), the fix isn’t to keep relying on a string that’s intentionally being hollowed out — it’s to request the specific Sec-CH-UA-* hints you actually need via Accept-CH, and justify each one, since every additional high-entropy hint requested is itself a small step back toward the fingerprinting surface this whole mechanism exists to shrink. To see which response headers your own site already sends, including any Accept-CH or Vary, run it through AdminKit’s HTTP headers check. The same underlying tension — convenience and identifiability traded off against privacy by withholding detail until it’s explicitly needed — is why consumer operating systems moved to randomized MAC addresses for Wi-Fi by default; User-Agent Client Hints is the same idea applied to the browser’s own request headers. This guide is part of AdminKit’s IP and network cluster of guides and tools on what your connection and browser reveal.

This guide is general information, not a security audit of your specific network — see our disclaimer for what AdminKit's guidance does and does not commit to.

Frequently asked questions

What was wrong with the old User-Agent string?

Nothing was technically broken — RFC 9110 §10.1.5 simply defines it as a client-supplied identification string with no fixed schema, sent in full on every single request. The practical problem is that a detailed, always-sent string (exact browser build, OS version, sometimes device model) is passively readable by every server a browser talks to, with no user awareness or consent involved — exactly the passive fingerprinting that Google's own User-Agent Reduction documentation names as the motivation for change: "the granularity and abundance of detail can lead to user identification," and its default availability "can lead to covert tracking."

What does a reduced User-Agent string actually look like?

Browser brand, a generalized major version, broad device category (mobile or desktop) and platform name stay accurate; precise OS build numbers, device model and minor browser version are generalized to fixed placeholder-style values instead of the exact figure. A site that genuinely needs more than that has to ask for it explicitly, rather than receiving it automatically in every request header.

What is Sec-CH-UA, and how is it different from the User-Agent header?

Sec-CH-UA is one of several User-Agent Client Hints — separate HTTP request headers, defined by the WICG's User-Agent Client Hints specification, that report structured fields a server opts into individually. Per MDN's Client Hints documentation, a handful of "low-entropy" hints (Sec-CH-UA, Sec-CH-UA-Mobile, Sec-CH-UA-Platform, plus Save-Data) are sent by default since they carry little identifying detail on their own, while higher-detail "high-entropy" hints such as Sec-CH-UA-Model or Sec-CH-UA-Platform-Version are withheld until a server specifically requests them.

How does a server actually request the more detailed hints?

By sending an Accept-CH response header naming which hints it wants — for example Accept-CH: Sec-CH-UA-Model, Sec-CH-UA-Full-Version-List — on an earlier response. The browser then includes those specific headers on its subsequent requests to that origin, per the WICG specification's stated goal of "giving servers that really need some specific details about the client the ability to opt into receiving them," rather than every server receiving everything by default.

Does this mean the User-Agent header is going away?

Not entirely — it still exists and is still sent, just with less detail by default than before User-Agent Reduction, and RFC 9110 hasn't deprecated the header itself. Client Hints is additive: a server that does nothing still receives the (now-generalized) User-Agent string it always has; only a server that explicitly opts in via Accept-CH receives the more detailed, structured Sec-CH-UA breakdown instead.

Want AdminKit to watch this for you?

Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.

Huy Nguyen (David), Founder and CEO of Netbase JSC

Talk to an expert

Huy Nguyen (David), Founder & CEO, Netbase JSC

Ask whether this fix applies to your setup, or get a second pair of eyes on your DNS and mail records.