Free user agent string parser
User agent parser that names the fiction
Free to use, with no signup and no request limit: paste a User-Agent header here and this parser reports the browser and version, the rendering engine, the operating system, the device type and any bot signature, then reads back what every token in the string claims. Press Parse mine to run it against your own browser. It also tells you what the string is hiding — Chrome zeroes its build number, macOS has read 10_15_7 since 2020, Android reports version 10 and a device called K, and Windows 11 is indistinguishable from Windows 10.
- 100% free
- No signup
- 40 bot signatures
- Token-by-token
- Client Hints panel
- Browser
- Chrome 131.0.0.0
- Engine
- Blink 537.36
- Operating system
- Windows 10 or 11
- Device
- Desktop
- CPU
- 64-bit x86
- Bot
- no bot signature
- Length
- 111 characters
What this string is not telling the truth about
- Claims to be Mozilla 5.0, a browser last released in 2000.
- Reports WebKit 537.36, a build frozen in 2013 and no longer the engine in use.
- Claims Gecko compatibility while running Blink or WebKit.
- Claims to be Safari while being Chrome or a Chromium fork.
- Chrome's build and patch numbers are zeroed; only the major version is real.
- Windows 11 is indistinguishable from Windows 10 here — both report NT 10.0.
Token by token
Mozilla/5.0
The oldest lie in the string. Netscape called itself Mozilla, servers began gating content on it in 1995, and every browser since has copied the prefix rather than lose access.
(Windows NT 10.0; Win64; x64)
Windows 11 reports NT 10.0 exactly like Windows 10. Nothing in a User-Agent string can tell the two apart — Client Hints can, through platformVersion 13.0.0 or higher.
AppleWebKit/537.36
Frozen at 537.36 since Chrome 27 in 2013. It is a compatibility token now, not a build number — Blink stopped being WebKit in 2013.
(KHTML, like Gecko)
A comment block. This is where the platform, and sometimes the device, is declared.
Chrome/131.0.0.0
Chrome 110 and later report the minor, build and patch numbers as 0.0.0. Only the major version is real; the exact build is available through Client Hints if the site asks.
Safari/537.36
Chrome claims to be Safari here, for the same reason it claims to be Mozilla — a site that only served modern CSS to Safari would otherwise have blocked it.
Client Hints from your own browser
This browser exposes no navigator.userAgentData. Firefox and Safari have both declined to implement it, so on those browsers the User-Agent string is still the only signal a site gets.
What each client sends today
Eight strings worth keeping to hand, with the part of each one that no longer means what it says. Compare them and the pattern is hard to miss: the tokens that identify a vendor still work, and almost every version number has stopped moving.
| Client | String | What is frozen or false |
|---|---|---|
| Chrome 131, Windows | Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 | Build and patch zeroed since Chrome 110; NT 10.0 covers both Windows 10 and 11 |
| Edge 131, Windows | …Chrome/131.0.0.0 Safari/537.36 Edg/131.0.2903.86 | Only the Edg token carries a real build number — the Chrome token beside it does not |
| Chrome 131, Android | Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36 | Android version pinned to 10 and the model to K, whatever the phone actually is |
| Safari 17.5, iPhone | Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1 | Mobile/15E148 has shipped with many iOS releases and identifies nothing |
| Safari 17.5, macOS | Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15 | macOS frozen at 10_15_7 since Big Sur; Apple Silicon still reports Intel |
| Firefox 130, macOS | Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:130.0) Gecko/20100101 Firefox/130.0 | Gecko build date fixed at 20100101; macOS rounded down to 10.15 since Firefox 87 |
| Googlebot | Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) | Googlebot/2.1 has not changed since 2004; the renderer behind it is evergreen Chromium |
| GPTBot | Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbot | Advertises WebKit but executes no JavaScript at all — the content has to be in the HTML |
Where the missing detail went
User-Agent Client Hints split the old string into eight headers and made most of them opt-in. Three are sent on every request; the other five arrive only after a site asks for them with an Accept-CH response header, which is the entire design — a site that wants the device model now has to say so, and that request is visible.
| Header | Availability | Replaces |
|---|---|---|
| Sec-CH-UA | Low — always sent | The browser brand and major version, plus a GREASE entry |
| Sec-CH-UA-Mobile | Low — always sent | The bare Mobile token in a Chrome Android string |
| Sec-CH-UA-Platform | Low — always sent | Windows, macOS, Android, Linux — the name only |
| Sec-CH-UA-Platform-Version | High — must be requested | The real OS version, including 13.0.0 and up for Windows 11 |
| Sec-CH-UA-Arch | High — must be requested | x86, arm and the Win64 / WOW64 tokens |
| Sec-CH-UA-Bitness | High — must be requested | The 64 in x64 |
| Sec-CH-UA-Model | High — must be requested | The Android device model that is now reported as K |
| Sec-CH-UA-Full-Version-List | High — must be requested | The build and patch numbers Chrome zeroed out |
One detail catches everyone the first time: the brand list in Sec-CH-UA always contains a deliberately fake entry such as "Not_A Brand";v="24". It is called GREASE, the punctuation and text change between releases, and it exists so that code parsing the list has to handle unknown brands rather than hard-coding three.
How to parse a user agent string
One string in, six facts out, plus what the string is quietly withholding.
Drop a string in, or use your own
Paste the value of the User-Agent header into the box — from a log line, a request in DevTools, or an analytics export. Parse mine fills it with your own browser's string, read from navigator.userAgent after the page mounts. Nine example strings sit under the box for comparison, from Chrome on Android to GPTBot.
Read the four facts, then the fine print
The panel gives browser and version, rendering engine, operating system and device type, followed by CPU architecture, bot signature and the length of the string. Under it, the amber list names every claim in this particular string that is not true — a frozen macOS version, a zeroed Chrome build, an Android model replaced by the letter K.
Compare it with what Client Hints say
The bottom panel reads navigator.userAgentData from your own browser: the brand list, the mobile flag and the platform name are always available, and Request high-entropy values asks for the platform version, architecture, bitness, device model and full version list. Firefox and Safari return nothing here, which is itself the answer to whether you can rely on hints alone.
Technical specifications
| Fields extracted | Browser and version, rendering engine and version, operating system and version, device type, vendor and model, CPU architecture, bot signature |
|---|---|
| Browsers recognised | 24 patterns including Chrome, Edge, Firefox, Safari, Opera, Samsung Internet, Vivaldi, Brave, Yandex, UC Browser, and the iOS variants CriOS, FxiOS and EdgiOS |
| Bot signatures | 40, split between search crawlers, AI crawlers (GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot, Bytespider), preview fetchers, SEO crawlers, monitors and HTTP libraries |
| Token annotations | Every product token and comment block in the string is explained individually, including the ones that are frozen or fictional |
| Client Hints | Reads navigator.userAgentData for brands, mobile and platform, and requests platformVersion, architecture, bitness, model, uaFullVersion and fullVersionList on demand |
| Known-frozen values detected | AppleWebKit/537.36, Chrome build 0.0.0, macOS 10_15_7, Firefox macOS 10.15, Windows NT 10.0, Android 10 with model K, and Gecko build 20100101 |
| Longest real strings | Around 250 characters; anything past 500 is almost always an appended corporate application token |
| Processing location | Your browser — the string is matched against regular expressions in this tab and is never uploaded, stored or logged |
Frequently asked questions
Why does every browser claim to be Mozilla?
Because in 1995 servers started checking for it. Netscape Navigator identified itself as Mozilla/2.0 and sites began serving frames only to that name, so when Internet Explorer wanted the same content it announced itself as Mozilla/4.0 (compatible; MSIE 4.0). Every browser since has inherited the prefix for the same defensive reason: the cost of dropping it is being handed a worse page by some server nobody has maintained since 2003. Mozilla/5.0 is now a fixed four-character apology at the front of a string that otherwise describes something else entirely.
Why does Chrome say it is Safari?
For the same reason, one layer down. Safari was built on KHTML, so it announced AppleWebKit (KHTML, like Gecko) to inherit the content sites were already serving to Gecko. Chrome then shipped with WebKit, copied Safari's tokens to inherit what sites served Safari, and kept every one of them after switching to Blink in 2013 — including AppleWebKit/537.36, which is a build number frozen at the moment of the fork. The result is a Chrome string that names four rendering engines and runs a fifth.
Can I tell Windows 11 from Windows 10?
Not from the User-Agent string. Both report Windows NT 10.0, because Microsoft never incremented the kernel version for Windows 11 and browsers report the kernel version. The only reliable signal is the Client Hint Sec-CH-UA-Platform-Version: Windows 11 reports 13.0.0 or higher, Windows 10 reports 1.0.0 to 10.0.0, and the mapping is Microsoft's own. That hint is high-entropy, so a site has to ask for it explicitly, and only Chromium browsers answer.
How do I detect an iPad?
You mostly cannot, and that is deliberate. Since iPadOS 13, Safari on iPad defaults to Request Desktop Website, which makes it send a string identical to Safari on a Mac — Macintosh, Intel Mac OS X 10_15_7 and all. The accepted workaround is to combine the string with navigator.maxTouchPoints, since a Mac reports 0 and an iPad reports 5. Anything that depends on a substring match for iPad has been quietly mis-classifying tablets as desktops since 2019.
Is the User-Agent string being removed?
No — it is being frozen, which is a different and more awkward thing. Chrome's User-Agent Reduction shipped in stages between Chrome 101 and Chrome 113: the minor, build and patch numbers became 0.0.0, the desktop platform version stopped updating, and on Android the version was pinned to 10 with the device model replaced by K. The header itself still goes out on every request and will indefinitely, so parsing it is not obsolete — it is simply less informative than it looks, and the missing entropy moved into the Sec-CH-UA hints.
Can I block bots by their User-Agent?
You can filter the polite ones, and only those. A User-Agent is a client-supplied string with no verification of any kind, so anything unwelcome can copy Chrome's string exactly and usually does — the crawlers that identify themselves as Googlebot or GPTBot are the ones cooperating with you. Google, Bing, OpenAI and Anthropic all publish IP ranges or support reverse-DNS verification for exactly this reason: match the name, then confirm the address, and treat the string alone as a hint rather than a fact.
Is it safe to paste a User-Agent from my logs?
Yes — the string never leaves this tab. Parsing is regular expressions running in your browser, so nothing is uploaded or recorded, which matters because a full User-Agent is a real fingerprinting surface: corporate builds append internal application names, and a rare combination of browser, platform and version can identify one person out of millions.
About User-Agent strings
A User-Agent string is not a description of a browser. It is a sedimentary record of thirty years of compatibility negotiation, in which each new engine copied the tokens of the one before it to avoid being served a worse page. Read a modern Chrome string in order and it claims to be Mozilla, then WebKit, then KHTML, then Gecko, then Chrome, then Safari — six identities, one of which is true. Nothing in it is verified either: the value is chosen by the client and can be set to any bytes at all, which is why it belongs in analytics and diagnostics rather than in an access-control decision.
What changed recently is how much of it is real. Chrome’s User-Agent Reduction ran from Chrome 101 through Chrome 113 and zeroed the minor, build and patch numbers, froze the desktop platform version, and on Android replaced the version and device model with a constant 10 and the letter K. Safari froze macOS at 10_15_7 when Big Sur shipped and still reports Intel on Apple Silicon. Firefox rounds the platform down deliberately as a fingerprinting countermeasure. The entropy those changes removed reappeared as Client Hints, which are opt-in and Chromium-only — so a parser that once told you the exact patch level of a browser now tells you a major version and a platform family, and any analysis built on more precision than that has been drifting for years.
The practical advice has not moved: detect features, not browsers. Where you genuinely need the client — serving a platform-specific download, or excluding a known-broken build — combine the string with something it cannot fake alone, such as navigator.maxTouchPoints for the iPad case or a verified reverse-DNS lookup for a crawler. If the strings you are working with came out of a request you are reconstructing, the curl converter carries the same headers into runnable code, and when you are building the pattern that matches a fleet of these strings, the regex tester will save you the third round of escaping.
Where the string is read
Only in this tab. The patterns run against the text in the box on your own machine, and neither the string you paste nor the one behind Parse mine is transmitted, logged or stored — worth knowing, because a full User-Agent is genuinely identifying: corporate builds append internal application names, and an unusual browser-and-platform combination can single out one person.