What does a User-Agent string actually reveal, and what are its limits?
A User-Agent string is a header your browser sends with every request, typically naming the browser, its rendering engine, the operating system and a coarse device type — but it's entirely self-reported, so any software can set it to any value. AdminKit's User-Agent tool shows exactly what yours reveals; treat the result as a hint, never a verified fact.
By AdminKit team, Netbase JSC · Updated
Key takeaways
- A User-Agent string usually reveals four things: browser and major version, rendering engine, operating system, and a coarse device type.
- Most of the string is compatibility padding. Almost every browser starts with
Mozilla/5.0, and Chromium browsers also claim to be “like Gecko” and Safari. - Chromium browsers now freeze parts of the string, so the OS version and device model you see are often fixed placeholder values, not the real ones.
- The string is self-reported. Anything can send any value, so treat it as a hint; confirm crawler claims with reverse DNS and support for features with feature detection.
What is the User-Agent header?
Every HTTP request your browser makes carries a User-Agent header, a standard field defined by RFC 9110 (HTTP Semantics). In principle it identifies the “user agent” — the software making the request — but in practice, decades of websites checking it for specific substrings has turned the string itself into a messy, historically accumulated piece of text that often includes compatibility tokens referencing entirely different, older browsers for backward-compatibility reasons. AdminKit’s User-Agent tool reads navigator.userAgent directly in your browser — the same value sent to every site you visit — and parses it with a lightweight parser, entirely client-side, with no server round trip or third-party database involved.
MDN’s User-Agent reference gives the general syntax as a list of products with optional comments, and the usual browser shape as:
User-Agent: <product>/<product-version> <comment>
User-Agent: Mozilla/5.0 (<system-information>) <platform> (<platform-details>) <extensions>
How do you read the tokens in a real string?
Take the Chrome on Windows example MDN publishes and split it at the spaces between products:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36
| Token | What it says | How much to trust it |
|---|---|---|
Mozilla/5.0 | “Mozilla-compatible”; MDN notes almost every browser sends it for historical reasons | Carries no information |
(Windows NT 10.0; Win64; x64) | Platform and CPU | Platform yes; Chromium reports this exact value on every current Windows version |
AppleWebKit/537.36 (KHTML, like Gecko) | Engine lineage, kept for compatibility | Blink browsers send a fixed 537.36 |
Chrome/143.0.0.0 | Browser and version | Major version real; the .0.0.0 is the reduced minor version |
Safari/537.36 | Another compatibility claim | Present in Chrome, Edge and Opera strings too |
Read that way, a long string often carries only three or four real facts. The rest exists so that old server-side checks for “Mozilla”, “Gecko” or “Safari” keep working.
What does it reveal when parsed?
A parsed User-Agent string typically yields four categories of information: the browser name and version, the rendering engine powering it (Blink for Chrome/Edge/most Chromium browsers, Gecko for Firefox, WebKit for Safari), the operating system, and a coarse device-type classification (desktop, mobile, tablet, or automated bot/crawler). Sites commonly use this for genuinely useful, low-stakes purposes: serving a mobile-optimized layout, warning about an unsupported old browser, or routing analytics by platform. None of these uses require certainty — a best-effort guess is good enough for them, which is part of why the header has survived in its current loosely structured form for so long.
The major browsers each add their own marker to a shared base. These examples are copied from MDN’s reference:
Firefox (Windows): Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0
Edge (Windows): Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0
Chrome (Android): Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36
Safari (iPhone): Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1
Per MDN, Edge appends Edg/ on desktop (EdgA/ on Android, EdgiOS/ on iPhone), Opera appends OPR/, and Chrome on iPhone adds CriOS/. MDN also notes that non-Apple browsers on iPhone are still built on WebKit, so their strings look like Safari’s. In Firefox’s string, Gecko/20100101 is a fixed value on desktop; the real engine version is the rv: number.
Why does the order of parser rules matter?
Because the markers stack. An Edge string contains Chrome/ and Safari/ as well as Edg/, so a parser that checks for Chrome first labels every Edge visitor as Chrome. AdminKit’s own parser therefore tests the most specific markers first:
| Order | Browser rule | Matches on |
|---|---|---|
| 1 | Edge | Edg/, EdgA/, EdgiOS/ or Edge/ |
| 2 | Opera | OPR/ or Opera/ |
| 3 | Samsung Internet | SamsungBrowser/ |
| 4 | Firefox | Firefox/ |
| 5 | Chrome | Chrome/ |
| 6 | Safari | Version/ followed by Safari |
The same parser treats a string as a bot when it contains common crawler words such as bot, crawl or spider, or named crawlers such as Googlebot or GPTBot. That too is a guess based on what the client chose to say about itself.
Why is it a hint, never a fact?
The critical limitation is that a User-Agent string is entirely self-reported by the client making the request. A browser chooses what to send; nothing in the protocol verifies it against the software actually running. This means any client — a different browser deliberately impersonating another, a command-line tool like curl, an automated script, or malicious software — can set this header to literally any value it wants. A site receiving a User-Agent claiming to be “Chrome on Windows” has no built-in way to confirm that’s true. This is why security-relevant decisions (access control, fraud detection, bot-blocking) that rely on User-Agent alone are inherently weak; a request pretending to be a normal browser is trivially easy to construct — one reason a security analyst triaging a suspicious request treats a parsed User-Agent as a hint to weigh, not a verdict.
One flag is all it takes:
curl -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36" https://www.example.com/
Crawler claims are the case where you can check. Google’s documentation on verifying Googlebot describes a reverse DNS lookup on the requesting IP, a check that the name ends in googlebot.com, google.com or googleusercontent.com, and a forward lookup confirming that name resolves back to the same IP. Google also publishes JSON lists of its crawler IP ranges, so a request can be matched against those instead of, or as well as, DNS. Our guide on verifying a crawler’s User-Agent claim with reverse DNS walks through the lookup step by step.
Why are browsers sending less of it?
Modern browsers have been progressively reducing how much detail the default User-Agent string carries, a change generally called User-Agent Reduction. The motivation is privacy: a detailed, passively-sent header is available to every site a browser visits without the visitor doing anything or being asked, which makes it a convenient building block for fingerprinting — identifying or re-identifying a visitor by combining several passive signals rather than using cookies. In its place, Chromium-based browsers are steering sites toward User-Agent Client Hints, defined in the WICG specification, an opt-in model where a site has to explicitly request specific details (browser version, platform, and so on) through separate headers, rather than receiving everything by default with every single request. This shifts the default from “broadcast everything, to everyone, always” to “reveal only what’s explicitly asked for,” which is a meaningfully different privacy posture even though the underlying information can still be requested when genuinely needed.
The visible effect, documented on the Chromium project’s reduction page: on Android the string always says Android 10 and the device model K, minor version numbers always read 0.0.0, and each desktop platform reports one fixed value. A parsed result that says “Android 10” from a current Chrome browser is the placeholder, not the phone’s real version.
How is a User-Agent string different from a fingerprint?
It’s worth being precise about scope: a User-Agent string on its own is a comparatively weak identifier. Every person running the same browser version on the same operating system sends an identical string, so it cannot distinguish between them individually. It becomes a meaningfully identifying signal only when combined with other passively observable details — screen resolution, installed fonts, timezone, graphics hardware characteristics, and more — a broader technique usually called browser fingerprinting. Understanding this distinction matters because the practical privacy fix is different depending on which problem you’re addressing: reducing User-Agent detail (which browser vendors are already doing by default) helps with one input into fingerprinting, but doesn’t eliminate the broader technique on its own.
What should a site use instead of sniffing the string?
MDN’s guide to browser detection recommends feature detection: test whether the browser supports the API or CSS feature you need, rather than inferring support from its name. Mobile detection is its main example of misuse. What sites usually want is “touch-friendly and small screen”, which navigator.maxTouchPoints and CSS media queries answer directly.
What should you do with this information?
Checking your own browser’s User-Agent string with AdminKit’s User-Agent tool is a quick way to see exactly what every site you visit already receives about your browser and operating system by default, with no setup required. If you’re evaluating what else your connection reveals passively to sites you visit, AdminKit’s my IP tool shows the other baseline identifier — your public IP address — that’s visible on every request regardless of browser settings, and our guide on IPv6 and home devices covers a related identifier: why a device’s own IPv6 address, not just your network’s shared IP, can be directly reachable from the internet. See how AdminKit’s User agent tool compares to WhatIsMyBrowser.com if you’re deciding between the two, or the wider roundup of free User-Agent parser tools for how it stacks up against the rest of the category. If the string you’re reading claims to be a known crawler rather than an ordinary browser, verifying a crawler’s User-Agent claim with reverse DNS covers how to actually confirm that, since the self-reported string alone never proves it. 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 information does a typical User-Agent string contain?
A best-effort breakdown of: browser name and version, the rendering engine (Blink, Gecko or WebKit), the operating system, and a coarse device type (desktop, mobile, tablet or automated bot). It's defined as a standard HTTP request header by RFC 9110, but the format of the value itself is a loose, historically accumulated convention rather than a strict schema, which is why parsing it reliably requires pattern-matching against known browser signatures rather than a single simple rule.
Can a website trust the User-Agent string it receives?
No, not as a verified fact. Any client — a browser, a script, a command-line tool like curl, or malware — can set its User-Agent header to whatever value it chooses, including impersonating a different browser entirely. Sites commonly use it for coarse decisions like serving a mobile-optimized layout, but security-relevant decisions should never rely on it alone, since it carries no cryptographic guarantee of accuracy.
Why are browsers sending less detail in the User-Agent string now?
Chromium-based browsers (Chrome, Edge and others) have progressively frozen and reduced the detail in their default User-Agent string, a change known as User-Agent Reduction, to limit passive fingerprinting — the practice of identifying a device from the fine-grained details a header passively reveals. In its place, they're steering sites toward User-Agent Client Hints, an opt-in mechanism where a site must explicitly request specific details rather than receiving them by default with every request.
How is a User-Agent string different from a fingerprint?
A User-Agent string alone is a weak identifier: many people running the identical browser version on the identical operating system send an identical string, so it can't distinguish between them. It becomes meaningfully identifying only when combined with other passively available signals — screen resolution, installed fonts, timezone, and more — a combination technique generally called browser fingerprinting, which is a broader and more invasive practice than reading the User-Agent header alone.
Does changing or spoofing my User-Agent string protect my privacy?
It can reduce one specific signal, but it isn't a complete privacy measure on its own. Because User-Agent is only one of many signals a site can read passively, spoofing it without addressing the others can sometimes make a browser look more unusual, and therefore more identifiable, rather than less — an inconsistency between a spoofed User-Agent and other signals a site can observe is itself a fingerprinting signal.
Want AdminKit to watch this for you?
Free checks tell you the state today. Protective DNS and monitoring tell you when it changes.
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.