Skip to content
FormatKit

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
Examples:

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.

Representative User-Agent strings for common browsers and crawlers, with the frozen or misleading part of each identified
ClientStringWhat is frozen or false
Chrome 131, WindowsMozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36Build 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.86Only the Edg token carries a real build number — the Chrome token beside it does not
Chrome 131, AndroidMozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36Android version pinned to 10 and the model to K, whatever the phone actually is
Safari 17.5, iPhoneMozilla/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.1Mobile/15E148 has shipped with many iOS releases and identifies nothing
Safari 17.5, macOSMozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15macOS frozen at 10_15_7 since Big Sur; Apple Silicon still reports Intel
Firefox 130, macOSMozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:130.0) Gecko/20100101 Firefox/130.0Gecko build date fixed at 20100101; macOS rounded down to 10.15 since Firefox 87
GooglebotMozilla/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
GPTBotMozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.2; +https://openai.com/gptbotAdvertises 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.

User-Agent Client Hint headers, whether they are sent automatically, and which part of the old User-Agent string each one replaces
HeaderAvailabilityReplaces
Sec-CH-UALow — always sentThe browser brand and major version, plus a GREASE entry
Sec-CH-UA-MobileLow — always sentThe bare Mobile token in a Chrome Android string
Sec-CH-UA-PlatformLow — always sentWindows, macOS, Android, Linux — the name only
Sec-CH-UA-Platform-VersionHigh — must be requestedThe real OS version, including 13.0.0 and up for Windows 11
Sec-CH-UA-ArchHigh — must be requestedx86, arm and the Win64 / WOW64 tokens
Sec-CH-UA-BitnessHigh — must be requestedThe 64 in x64
Sec-CH-UA-ModelHigh — must be requestedThe Android device model that is now reported as K
Sec-CH-UA-Full-Version-ListHigh — must be requestedThe 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.

  1. 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.

  2. 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.

  3. 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 extractedBrowser and version, rendering engine and version, operating system and version, device type, vendor and model, CPU architecture, bot signature
Browsers recognised24 patterns including Chrome, Edge, Firefox, Safari, Opera, Samsung Internet, Vivaldi, Brave, Yandex, UC Browser, and the iOS variants CriOS, FxiOS and EdgiOS
Bot signatures40, split between search crawlers, AI crawlers (GPTBot, OAI-SearchBot, ClaudeBot, PerplexityBot, Bytespider), preview fetchers, SEO crawlers, monitors and HTTP libraries
Token annotationsEvery product token and comment block in the string is explained individually, including the ones that are frozen or fictional
Client HintsReads navigator.userAgentData for brands, mobile and platform, and requests platformVersion, architecture, bitness, model, uaFullVersion and fullVersionList on demand
Known-frozen values detectedAppleWebKit/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 stringsAround 250 characters; anything past 500 is almost always an appended corporate application token
Processing locationYour 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.