User-Agent Strings Explained

Anatomy of a modern User-Agent

Here's the User-Agent a recent Chrome on Windows 11 sends:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

That single line contains six separate product tokens, at least four of which are pretending to be something they're not. It claims to be Netscape Navigator (Mozilla/5.0), claims to be KHTML (Konqueror's engine), claims to be Gecko (Firefox's engine), and claims to be Safari — all before getting to the honest part (Chrome/131). Then it claims to be Safari again for good measure.

Reading a UA is less like parsing a structured data format and more like reading the archaeological record of the web browser wars. Every weird token is there because a website, somewhere, once broke when it wasn't. Let's dig through the layers.

Why it starts with Mozilla/5.0 — the oldest lie on the web

In 1994 Netscape's codename was Mozilla. The Navigator browser identified itself as Mozilla/1.0. Websites began branching on this token: "If it's Mozilla, serve the fancy JavaScript version; otherwise serve plain HTML."

When Microsoft shipped Internet Explorer 2 in 1995, it faced a cold reality: websites that checked for Mozilla would serve IE the stripped-down page. The fix? Microsoft made IE claim to be Mozilla/2.0 (compatible; MSIE 3.0; ...). Now sites would serve IE the full experience.

Every new browser repeated this trick. KHTML wanted pages meant for Gecko, so Safari's WebKit claimed to be "KHTML, like Gecko." Chrome wanted pages meant for Safari, so it claimed to be Safari. And they all still claim to be Mozilla, because a 2005-vintage PHP script somewhere still does if (strpos($ua, 'Mozilla') === false) { echo "Please use a modern browser"; }.

Every token, decoded

Enter Client Hints (Sec-CH-UA)

Because the UA is a tangled mess, Google proposed a replacement: User-Agent Client Hints. Instead of one big string, the browser sends several small, structured headers:

Sec-CH-UA: "Chromium";v="131", "Not_A Brand";v="24", "Google Chrome";v="131"
Sec-CH-UA-Mobile: ?0
Sec-CH-UA-Platform: "Windows"

These are sent automatically on every request — but only the coarse-grained ones. More detailed hints (platform version, architecture, device model, full version list) are sent only after the server opts in via an Accept-CH response header. This is called the "low entropy / high entropy" split: low-entropy hints go out to everyone; high-entropy hints require a server to ask.

The "GREASE" token. Notice the "Not_A Brand" in the example. That's deliberately random-looking chaff inserted so that servers are forced to parse the header properly instead of hardcoding the known brands. Chrome rotates the exact token occasionally to prevent servers from hardcoding it too.

Browser support. Chrome, Edge, Opera, Brave, and Vivaldi (all Chromium) send Client Hints. Firefox and Safari do not — their privacy models treat the additional signal surface as something to minimise rather than standardise.

Why Chrome froze the UA string

Before 2022, the Chrome UA on Windows looked like: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36

That single line carried the exact Windows build, the exact Chrome version down to the patch, the architecture, and the rendering engine version. For fingerprinting purposes that's a lot — Panopticlick-style fingerprinters got 8–12 bits of entropy from the UA alone.

Chrome's "UA reduction" project (2022–2023) rolled back most of that. In the modern frozen form:

• Windows NT version freezes at 10.0 regardless of actual Windows version.
• Chrome's minor/build/patch versions become 0.0.0.
• Architecture details (Win64; x64) remain but no longer distinguish Windows 10 from 11.

The fine-grained truth moved to Client Hints, where servers have to actively request it. Most ad tech still does, but analytics tools that don't bother now see a much blurrier picture.

Bot user-agents and how sites detect them

Not all UA strings come from browsers. A handful of common bot UAs:

Googlebot/2.1 (+http://www.google.com/bot.html)
Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)
GPTBot/1.0 (+https://openai.com/gptbot)
ClaudeBot/1.0 (+http://www.anthropic.com/claudebot)
facebookexternalhit/1.1
Twitterbot/1.0
curl/8.5.0
python-requests/2.31.0
Mozilla/5.0 (X11; Linux x86_64) PostmanRuntime/7.36.0

Well-behaved bots identify themselves and include a URL to their documentation. Scrapers that don't want to be blocked either copy a real browser UA wholesale or rotate through a pool of recent ones.

Sites don't rely on the UA alone for bot detection — a spoofed UA is trivial. They cross-check:

• Reverse DNS. Googlebot UAs that don't resolve to *.googlebot.com are fake.
• TLS fingerprint (JA3/JA4). Python's requests library negotiates TLS differently than Chrome, regardless of what UA it claims.
• Client Hints presence. A UA claiming Chrome 131 that doesn't send Sec-CH-UA is almost certainly fake.
• Behavioural signals. Mouse movement, scroll timing, navigation patterns.

Can you spoof your UA for privacy?

Two approaches actually help:

1. Use a browser with a unified UA for all its users. Tor Browser is the canonical example — everyone on a given Tor Browser version sends identical UA and UA-related hints, producing genuine anonymity through the crowd.
2. Use Firefox's privacy.resistFingerprinting preference, which normalises the UA, screen size, timezone, and language to a single Firefox default. It breaks some sites, but for the ones that still work you blend in with every other RFP user.

Spoofing to pretend to be a specific other browser (the "User-Agent Switcher" category of extensions) is mostly useful for compatibility ("make this old site think I'm IE11") rather than privacy.

Reading real UA strings

With the tokens decoded, some real-world UAs become readable:

iPhone running iOS 17 Safari

Mozilla/5.0 (iPhone; CPU iPhone OS 17_4 like Mac OS X)
AppleWebKit/605.1.15 (KHTML, like Gecko)
Version/17.4 Mobile/15E148 Safari/604.1

Real iPhone, iOS 17.4, Safari 17.4. The Mobile/15E148 is a generic build tag used by all iOS Safaris — it's not a device identifier despite looking like one.

Android 14 Chrome

Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36

Android 14 on a Pixel 8. The device model is still in the UA on Android — one of the more distinctive signals left in the post-reduction era. Chrome on Android hasn't removed this yet.

macOS Safari

Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)
AppleWebKit/605.1.15 (KHTML, like Gecko)
Version/17.3 Safari/605.1.15

Safari on macOS. Note 10_15_7 — frozen at macOS Catalina for compatibility even on Sonoma and later. The Intel claim is also frozen on Apple Silicon Macs, to keep sites that branch on CPU architecture from serving the wrong bundle.

A suspicious one

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Claims to be Chrome 90, which shipped in April 2021 — but any real Chrome that old has long since auto-updated. If a site sees this UA in 2026, it's almost certainly a scraper using a hardcoded UA from a scraping tutorial.

FAQ

Why does every user-agent start with Mozilla/5.0?

For historical compatibility. Netscape's codename was Mozilla, and websites in the 1990s branched on that token to decide whether to serve the feature-rich version of a page. Every browser since has claimed to be Mozilla/5.0 to avoid being downgraded. Removing the prefix today would break a long tail of old sites.

What's the difference between User-Agent and Sec-CH-UA?

User-Agent is a single free-form string. Sec-CH-UA is part of the newer Client Hints system: structured, machine-readable headers where coarse details are sent by default and fine-grained details require the server to opt in. Chromium browsers send both; Firefox and Safari send only User-Agent.

Can I spoof my user-agent for privacy?

Changing it usually hurts. A UA that disagrees with Client Hints, canvas fingerprint, and feature detection is itself a distinctive fingerprint. The only genuinely effective approach is to use a browser (Tor Browser, Firefox with resistFingerprinting) that unifies the UA across its entire user base.

Is User-Agent going away?

The string will stay for compatibility, but its information content is shrinking. Chrome has frozen most of its detail; Safari and Firefox hide even more. The real signals are moving to Client Hints (for sites that want them) or being removed entirely (for sites that don't need them).

What does a bot's user-agent look like?

Legitimate bots identify themselves openly (Googlebot, bingbot, GPTBot, ClaudeBot). Scrapers either copy a real browser UA or use library defaults like python-requests/2.31.0. Sites cross-check the UA with reverse DNS, TLS fingerprints, and behavioural signals to tell real bots from fake ones.