A plain-English guide to the User-Agent string: what it looks like, how to read each token, why it still says Mozilla, and how to check yours in seconds.
Every time your browser loads a page, it sends along a short line of text called the User-Agent string — a self-reported label announcing which browser, engine, and operating system you're using. It looks like meaningless gibberish at a glance, but each part is a distinct token, and reading it correctly tells you exactly what a website thinks it's talking to.
Key Takeaways
- The User-Agent (UA) string is a single HTTP header, sent on every request, that names your browser, rendering engine, OS, and device class.
- It reads like
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36— a sequence of tokens, not one solid phrase. - Almost every browser's UA still starts with
Mozilla/5.0for historical compatibility reasons, not because it's actually Mozilla software. - You can read your own UA instantly via
navigator.userAgentin DevTools, or by checking the request headers your browser sends. - The string is self-reported and easy to edit, so Chromium is migrating toward User-Agent Client Hints as a more structured, verifiable replacement.
What is a User-Agent string, plainly?
A User-Agent string is a line of text your browser volunteers on every HTTP request, in a header literally named User-Agent. Its job is to let servers adapt: send a mobile-friendly layout to phones, warn very old browsers about unsupported features, or just log which browsers actually visit a site. It's been part of the web since the earliest browsers in the early 1990s, and the format has stayed backward-compatible ever since — which is exactly why it looks so cluttered today.
Anatomy of a real User-Agent string
Here's a typical desktop Chrome UA string, broken into its parts:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36
| Token | Meaning |
|---|---|
Mozilla/5.0 | A legacy compatibility token — see below, it doesn't mean the browser is Mozilla/Firefox |
(Windows NT 10.0; Win64; x64) | Operating system (Windows 10/11) and CPU architecture (64-bit) |
AppleWebKit/537.36 | The underlying engine lineage the rendering engine descends from |
(KHTML, like Gecko) | A compatibility phrase claiming behavior similar to two other historical engines |
Chrome/124.0.0.0 | The actual browser and its version number |
Safari/537.36 | Another compatibility token, present because Chrome's engine, Blink, forked from WebKit (Safari's engine) |
Firefox and Safari follow the same pattern with different tokens — Gecko/20100101 Firefox/125.0 for Firefox, Version/17.4 Safari/605.1.15 for Safari — but the structure (platform block, then engine tokens, then browser name and version) is consistent across all of them.
Why almost every browser still says "Mozilla"
This is the part that confuses people the most: Chrome, Safari, Edge, and even some non-browser tools all start their UA with Mozilla/5.0, despite having nothing to do with the Mozilla project. The short version of the history: in the mid-1990s, Netscape Navigator's internal codename was "Mozilla," and sites started checking for that token to decide whether a visitor's browser supported then-advanced features like frames. When Internet Explorer wanted the same features enabled, it added Mozilla to its own UA string to pass those checks. Every subsequent browser followed suit to avoid being served a stripped-down page, and the token stuck permanently. It's a fossil of 1990s browser-detection wars, not a meaningful identifier — one of the best-known quirks in web history.
How to see your own User-Agent
There are two ways to check it, and they can occasionally disagree:
From JavaScript, open your browser's DevTools console and run:
navigator.userAgent
This returns the exact string the page's scripts can read.
From the raw request, open the DevTools Network panel, reload the page, click any request, and look for the User-Agent header in the request headers. This is what the server actually receives — normally identical to navigator.userAgent, though a browser extension or proxy can rewrite one without touching the other, which is itself a detectable inconsistency.
BrowserInsight's kernel check shows both your claimed User-Agent and your browser's real rendering engine side by side, so you can see at a glance whether they agree.
The User-Agent as an identity and fingerprinting signal
Because the UA string discloses OS, architecture, browser, and version on every single request without asking, it has always doubled as a passive identification signal — one input among the many that make up a browser fingerprint. That's part of why Chromium is gradually freezing the legacy string down to a generic stub and shifting toward User-Agent Client Hints (UA-CH), a structured API that discloses detail only when a server explicitly asks for it, rather than broadcasting everything by default.
A caveat: spoofing is easy, but it's easy to catch too
Because the UA string is just self-reported text, changing it takes nothing more than a browser setting or extension. People do this for testing, for accessing browser-restricted content, or for privacy. But the UA is only one signal among dozens a browser exposes, and the others rarely get changed to match — so a page claiming to be Safari while its JavaScript engine, client hints, and rendering quirks all say otherwise is a mismatch a site can catch quickly. If you're curious how that detection actually works, see how sites detect User-Agent spoofing. The takeaway for anyone editing their UA out of curiosity: it changes what one header says, not what your browser actually is.
Frequently Asked Questions
Why does my User-Agent say "like Gecko" if I'm not using Firefox?
(KHTML, like Gecko) is another compatibility fossil, not a real claim about your engine. It signals broad support for Gecko/KHTML-era layout behavior so older sites written for those engines still render acceptably. It appears in Chrome, Safari, and Edge regardless of which engine is actually running.
Is the User-Agent string the same as my browser fingerprint?
No — it's one input into a fingerprint, not the fingerprint itself. A full browser fingerprint combines the UA with canvas rendering, WebGL output, fonts, screen metrics, and more. The UA alone identifies broad categories (browser family, rough OS); it doesn't uniquely identify a device on its own.
Can two different browsers have the same User-Agent?
Yes. Because the string is self-reported, any browser can technically send whatever UA text it wants, including one copied from a completely different browser. That's exactly why sites cross-check the UA against other signals rather than trusting it in isolation.
Will the User-Agent string eventually disappear?
Not immediately, but its role is shrinking. Chromium is progressively freezing the legacy string to a low-detail stub while User-Agent Client Hints take over as the primary structured channel. Firefox and Safari currently have no UA-CH equivalent and continue to rely on the traditional string.
Conclusion
The User-Agent string looks cryptic, but it's just a compatibility-laden list of tokens — platform, engine lineage, and browser name and version — accumulated over three decades of browsers trying not to break each other's sites. Reading it is straightforward once you know the pattern, and checking your own takes one line in DevTools. Because it's self-reported, treat it as a claim rather than a guarantee — and if you want to see how your real engine and identity signals compare to what your UA claims, run BrowserInsight's kernel check.
Recommended Reading:
