User Agent Parser

Parse any user agent into browser, engine, operating system and device, generate the Client Hints that should accompany it, and see where a hint set contradicts the string.

  • Runs entirely in your browser
  • Results are not uploaded
  • No signup

Prefilled with the string this browser sends. Replace it with any string you want to read.

Client Hints this string implies

What a real browser sending that user agent would publish alongside it.

Paste a user agent on the left to see the hint set it commits to.

Compare against a real hint set

Paste the Sec-CH-UA headers actually being sent, one per line, or the JSON that navigator.userAgentData.getHighEntropyValues() returns. Every disagreement with the string above is listed field by field.

Paste a user agent first — the comparison is between that string and the hints beside it.

Now give every account its own device.

A clean browser is still one browser. Sendwin runs each profile in isolation with its own fingerprint, cookies and proxy, so the accounts you work on never look like they came from the same machine.

  • Isolated profiles, each with its own fingerprint and cookies
  • A proxy per profile, with the timezone bound to the proxy country
  • Windows, macOS and Linux — plus cloud sessions when you need them

The free plan includes 10 minutes of cloud browsing a day.

The same facts, published twice

The user agent string is the oldest identifying header on the web and by far the most decorated. Thirty years of compatibility workarounds mean every Chromium browser still opens with Mozilla/5.0, still claims KHTML, and still mentions Safari — none of which describes what it is. The information that survives is in the platform token and the tail: the operating system, the rendering engine version, and which brand actually built the browser. Paste a string here and it is broken down into browser, version, engine, operating system, OS version and device type, with the inherited tokens marked as the noise they are.

The more useful half of this page is the second one. A modern Chromium browser publishes the same facts twice: once in the string, and once as User-Agent Client Hints in Sec-CH-UA headers and navigator.userAgentData. Two independent sources for one fact is a free consistency check, and sites take it. Change the string alone and the hints keep faithfully describing the real browser, which is a contradiction rather than a disguise — and a contradiction is more identifying than the value you were trying to hide. So this page also derives the hint set a string implies, and diffs it against one you supply.

What a user agent string actually contains

A typical desktop string has four parts. The Mozilla/5.0 prefix is a historical artifact that every browser carries. The parenthesised platform token is the informative piece: Windows NT 10.0; Win64; x64, or Macintosh; Intel Mac OS X 10_15_7, or X11; Linux x86_64. Then come engine tokens — AppleWebKit/537.36 (KHTML, like Gecko) — which every Chromium browser reproduces verbatim regardless of what it is. Finally the tail names the browser and version, and its order matters: a Chrome token followed by Edg means Edge, followed by OPR means Opera, and Chrome alone means Chrome.

Client Hints and why they replaced the string

Client Hints split the same information into fields a server asks for. The low-entropy set is sent on every request — the brand list, a mobile flag and the platform name — and covers what most sites need. Everything more specific is high-entropy and withheld until requested through Accept-CH or read in JavaScript with getHighEntropyValues: platform version, architecture, bitness, device model and the full version list. The point is that the browser stops broadcasting its full profile to everyone by default, and a site that needs the detail has to ask for it, which is at least visible.

Where a string and its hints contradict each other

This is the check worth running. A string claiming Windows next to Sec-CH-UA-Platform reporting macOS cannot both be true. Neither can a desktop platform token beside a mobile flag of ?1, a brand list that omits the browser the string names, or a full version list whose major version disagrees with the Chrome token. The subtlest case is absence: Chromium sends these hints, so a browser that presents a Chromium user agent and publishes no Client Hints at all has already contradicted itself. Every one of these is cheap for a site to score and impossible to explain away.

What the page reads

  1. 1

    Paste a user agent

    Any string, or start from the one this browser sends. It is parsed into browser, version, engine, operating system, OS version and device type, with the inherited compatibility tokens identified separately.

  2. 2

    Read the hints it implies

    The page derives the Client Hints a real browser sending that string would publish — brand list, mobile flag, platform, platform version, architecture and full version list — so you can see the second half of the identity the string commits you to.

  3. 3

    Diff against a real hint set

    Paste the hints actually being sent and every disagreement is listed field by field. Each row is a contradiction a site can read on the first request, without measuring anything else about the browser.

User agent and Client Hints FAQ

Why every browser claims to be Mozilla, what user agent reduction changed, and which fields have to agree with each other.

It is a header your browser sends with every request, identifying itself so a server can adapt what it returns. In practice it is a compatibility artifact: decades of sites sniffing for particular browsers pushed every vendor into copying everyone else's tokens, which is why a modern Chrome string still names Mozilla, KHTML and Safari. The parts that still carry information are the platform token and the browser name and version at the end.

They are a set of request headers, the Sec-CH-UA family, that carry the same facts as structured fields instead of one long string. A small low-entropy subset — brands, mobile flag, platform — is sent automatically, and the detailed values such as platform version, architecture and model are sent only if a site explicitly asks for them. The goal was to stop every visitor broadcasting a full hardware and OS profile to every site by default, and to make the requests for detail visible rather than implicit.

No, and on its own it usually makes you easier to pick out. The string is one of many things a page reads, and the rest do not move with it: Client Hints still report the real platform, the WebGL renderer still names a GPU and a graphics backend that imply an operating system, the installed fonts still belong to the real one, and the timezone stays put. A Windows string surrounded by macOS evidence is not anonymity, it is a contradiction — and contradictions are what detection systems score.

It is Chromium's ongoing effort to freeze and trim the string so it stops being a fingerprinting surface. Minor version numbers are reported as zeros, the macOS version is capped at 10_15_7, Windows NT stays at 10.0, and the Android device model is replaced with a generic value. The consequence for anyone parsing it is that a precise-looking version in a modern string may not be precise at all — the accurate figures moved into the high-entropy Client Hints, where a site has to ask for them.

History. Early sites gated features on the browser name, so each new browser added the tokens of the ones already supported, and none of them could ever be removed without breaking somebody's detection code. The practical effect is that the leading tokens carry no information at all — and that a string tidied up to remove them stands out, because no shipping browser sends a clean one.

All of the overlapping ones, because they come from the same build. The platform token has to agree with Sec-CH-UA-Platform, the device class with the mobile flag, and the brand list has to include the browser the string names with the same major version. If high-entropy hints are supplied, platform version, architecture, bitness, model and the full version list have to describe the same machine and the same build. There is no legitimate configuration in which a browser disagrees with itself about what it is.

It can read this browser's own string to prefill the box, and that is it. Parsing, hint generation and the comparison all happen on this page, nothing is uploaded and no result is stored. Worth remembering, though, that every site you visit already receives your user agent in the request itself — that is how HTTP works, and no tool can withhold it for you.

Still have questions? Talk to us →

A parsed string is a claim, not a verification

Parsing a user agent is pattern matching on text that anyone can write, so everything on this page describes what a string claims rather than what a browser is. A parsed result is not verification: only the signals a browser cannot easily rewrite — rendering output, GPU limits, fonts, timezone — can say whether the claim holds up. If that is the question you are asking, the fingerprint checker measures those directly.

Change the string and everything else follows.

Sendwin generates each profile's user agent, Client Hints, platform, fonts and GPU together, so the browser never has to explain why one field disagrees with the next. Free for 30 days on Windows, macOS and Linux.

30-day free trial · $0 today · cancel anytime — your profiles stay on your machine

Try in the cloud →Start free trial