See how your browser introduces itself to servers: your user agent string, your Client Hints, your screen, language and time zone. Paste any user agent string and split it into browser, engine, operating system and device type. Everything is parsed in your browser and no data is sent anywhere.
Ready-made examples
Structured values the browser reports independently of the user agent string. As the string is frozen, this is becoming the real source.
These values are read from the running browser, not from the user agent string. They are what actually decides what a site can show you.
This page sends nothing: the parsing, the Client Hints reading and the environment values all run in your browser. The string you paste never reaches a server and is never stored.
The user agent string your browser sends to servers appears at the top the moment you open the page, and copies with one click. The browser, engine, operating system and device type are parsed at the same time.
Paste any user agent string you are curious about into the box, or click one of the ready-made examples. The result updates as you type, and what you paste is never sent anywhere.
On Chromium-based browsers navigator.userAgentData is read as well. What the classic string no longer tells you, such as Windows 10 against Windows 11 and the full browser version, shows up here.
Screen resolution, viewport, pixel ratio, languages, timezone, core count, touch points and secure context are listed on the same page. All of it is read from the browser.
A user agent is a header the browser sends with every HTTP request: User-Agent. It carries the browser's name and version, the operating system it runs on and sometimes the device model. A server reads that single line to guess what is on the other end; whether to send the mobile page, which download link to offer, and whether the request is a bot are usually decided from it.
But a user agent is a declaration, not an identity document. Whatever the browser writes is what gets sent; one client-side setting or an extension changes it, and with curl you can write anything at all. Security decisions are therefore never built on it. Parsing a string tells you what the other end claims to be, not what it is.
The term is user agent everywhere that matters: it is the name used in the HTTP specification, in browser developer tools and in every reference.
Because of a thirty-year chain of imitation. Mosaic came first in 1993; Netscape followed a year later, took Mozilla as its code name and wrote Mozilla/1.0 into its string. Once Netscape became the first browser with frame support, sites started looking for Mozilla in the string and sending the framed page only to it.
To get the same pages, Internet Explorer introduced itself as Mozilla/4.0 (compatible; MSIE 4.0): I am like Mozilla, but I am really IE. Then Safari arrived, wrote like Gecko because it descends from the KHTML engine, and started with Mozilla too. Chrome wrote KHTML, Safari and Mozilla all at once. When Edge moved to Chromium it put Chrome, Safari and Mozilla in its string together and appended Edg at the end.
Today there is hardly a browser that does not begin with Mozilla/5.0, and the phrase says nothing at all. In the same way, like Gecko and the AppleWebKit version number in most strings are historical residue. Reading a string correctly means knowing exactly which of these lies means what.
The string below belongs to Chrome running on Windows. Of its six parts, only two actually carry information.
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36
| Token | What does it say? |
|---|---|
Mozilla/5.0 |
Nothing. Historical residue carried for Netscape compatibility; today almost every browser has it. |
(Windows NT 10.0; Win64; x64) |
The platform section: the Windows kernel version and the architecture. NT 10.0 means both Windows 10 and Windows 11, and the string cannot separate them. |
AppleWebKit/537.36 |
The WebKit version. It has been fixed since Chrome moved to Blink in 2013 and is no longer a real version. |
(KHTML, like Gecko) |
More residue: a compatibility claim towards KHTML, WebKit's ancestor, and towards Gecko, Firefox's engine. |
Chrome/153.0.0.0 |
The real information: the browser's name and version. The minor digits are now zeroed, so the real version may be 120.0.6099.129. |
Safari/537.36 |
A compatibility claim added so that sites written for Safari keep working. It does not mean the browser is Safari. |
Whether a user agent parser gets the answer right depends on the order in which it looks for the tokens below. The parser on this page runs from the most specific match to the most general, and that is the only reason it does not mistake Edge for Chrome, Opera for Chrome or Chrome for Safari.
| Token | What it means | The trap |
|---|---|---|
Edg/ |
Microsoft Edge (Chromium) | The same string also says Chrome and Safari. Look for Chrome first and Edge disappears. |
EdgA/ EdgiOS/ |
Edge on Android and iOS | On iOS the engine is WebKit, not Blink. |
OPR/ |
Opera (Chromium) | The string says Chrome. Old Opera instead starts with Opera/9.80 and carries its real version in the Version token. |
CriOS/ FxiOS/ |
Chrome and Firefox on iOS | Apple's rules put both on WebKit, so reading the engine as Blink or Gecko is wrong. |
SamsungBrowser/ |
Samsung Internet | It also carries a Chrome version, and that version lags behind the browser's own. |
; wv) |
Android WebView | Not a standalone browser but a view embedded in an application. It is regularly confused with Chrome. |
Version/26.5 Safari/605.1.15 |
Safari | Safari's version lives in the Version token; the number after Safari is a build number. |
Macintosh; Intel Mac OS X 10_15_7 |
macOS | The version is frozen, Apple Silicon also writes Intel, and an iPad in desktop mode sends the very same string. |
Android 10; K |
Android | A reduced string. Chrome no longer writes the real Android version or the device model. |
Trident/ |
Internet Explorer | The IE 11 string contains no MSIE token; the version is in the rv part. |
The user agent string became a fingerprinting surface precisely because of its detail: the OS patch level, the device model and the full version together were enough to single out one browser in a crowd. Chromium therefore began freezing the string and introduced a structured mechanism in its place, called User Agent Client Hints.
The idea is simple: low-entropy fields are sent on their own, high-entropy ones only if the server asks. The browser sends Sec-CH-UA, Sec-CH-UA-Mobile and Sec-CH-UA-Platform with every request. For the device model, the full version, the architecture and the platform version the server has to request them with an Accept-CH header. The same values are reachable from JavaScript through navigator.userAgentData; the high-entropy ones need a getHighEntropyValues call that returns a promise.
You can see the practical result at the top of this page: Windows 10 and Windows 11 cannot be told apart from the classic string, but they can from the Client Hints platform version. Chrome's full version, likewise, now lives only on the hints side. Firefox and Safari never implemented the API, so on those browsers the classic string is all there is.
| Question | Classic string | Client Hints |
|---|---|---|
| Windows 10 or 11? | Cannot tell | Platform version 13 or above means Windows 11 |
| Full browser version | Major version only | Full four-part version |
| CPU architecture | Usually misleading | Architecture and bitness separately |
| Device model | Hidden on Android now | Reported on request |
| Firefox and Safari support | Supported | Not supported |
Your user agent string, your Client Hints and your browser environment are written out the moment the page opens. One click copies them.
It does not read Edge as Chrome, Opera as Chrome or iOS Chrome as Blink. The rules run from the most specific to the most general and were measured against real strings.
When Windows 10 and 11, or macOS and an iPad in desktop mode, cannot be told apart, it says so instead of guessing.
Googlebot, Bingbot, AI crawlers, curl, Wget and HTTP libraries are not shown as browsers; they are marked as a separate client type.
Screen, viewport, pixel ratio, language, time zone, core count, memory, touch points and secure context in a single list.
No request to a server, no call to a third party. Neither the string you paste nor the values that are read ever leave your browser.
A user agent is the User-Agent header your browser sends with every HTTP request. It carries the browser name and version, the operating system it runs on and sometimes the device model. Servers read that single line to decide whether to send the mobile page, which download link to offer, or whether the request is a bot. It is a declaration rather than an identity document, though: whatever the browser writes is what gets sent, and it is trivial to change.
Opening this page is enough: your own user agent string is written at the top and copies with one click. Below it you get the browser, engine, operating system and device type parsed out of that string, together with browser details such as your screen resolution, viewport size, languages and time zone. These values are read from the running browser, not from a server.
Because of a thirty-year compatibility chain. Netscape called itself Mozilla and sites started looking for Mozilla in the string; to get the same pages, Internet Explorer introduced itself as Mozilla/4.0 (compatible; MSIE 4.0). Safari wrote like Gecko because it descends from KHTML, Chrome wrote both Safari and Mozilla, and Edge, once on Chromium, wrote all three and appended Edg. Today Mozilla/5.0 and like Gecko say nothing at all.
It can be changed, which is exactly why it cannot be trusted. One setting in developer tools, an extension, or curl -A is enough to send any string you like. No access control, licence check or security decision should therefore rest on the user agent. For feature support the right method is not to read the string but to test for the feature itself.
Yes, gradually. Because the detail in the string made fingerprinting easy, Chromium froze it: the minor version digits were zeroed and the Android version and device model were reduced. The Sec-CH-UA family took its place; low-entropy fields are sent on their own, while fields such as the device model and the full version are sent only if the server asks with Accept-CH. The JavaScript equivalent is navigator.userAgentData. Firefox and Safari never implemented the API.
No. This page makes no request to a server at all: the parsing, the Client Hints reading and the environment values such as screen and time zone all run in your browser. No third-party service is called and nothing is stored. Close the tab and no trace is left.