piapia123
en

User-Agent Parser

Web

Everything runs locally in your browser — nothing is uploaded

Input
Drop a file here to load its contents
Output

Read a user agent string into a browser, version, operating system, device type and rendering engine — and see exactly which rules matched, so the conclusion is inspectable instead of a bare name. That matters, because a user agent is a line of text the client writes about itself: browsers copy each other on purpose (Chrome claims to be Safari, Edge claims to be both Chrome and Safari) and anything automated is free to lie. Treat the result as a rough hint, never as an authoritative check, and read the NOTES section before you rely on any of it.

Features

  • Browser and version, covering Edge, Opera, Samsung Internet, Vivaldi, Yandex and UC
  • Rendering engine: Blink, WebKit, Gecko, Trident, EdgeHTML or Presto
  • Operating system and version: Windows, macOS, iOS, iPadOS, Android, ChromeOS, Linux
  • Device type: desktop, mobile, tablet, bot or command-line client
  • ⚠️ You can supply Client Hints (the JSON of `navigator.userAgentData`), which takes precedence over the string: the full browser version (the string pads it to 120.0.0.0), and the real Windows 11 and macOS versions (both frozen in the string) come only from there
  • Each field is labelled with whether it came from the string or from Client Hints — they are not equally trustworthy, and without the source there is no way to judge
  • If Client Hints were supplied but the JSON cannot be read, it says plainly that they were not used instead of ignoring them silently
  • Lists the matched rules so you can see what the conclusion was based on
  • Every result carries notes: which two systems cannot be told apart, which token is an imitation
  • Reports how many browser markers the string carries and which one won
  • Switch to JSON output to feed the result straight into a script
  • A “Use my current browser” button in the input fills in the user agent of this very machine and parses it immediately — no digging through developer tools

How to use

  1. Paste a user agent string into the input box
  2. Or press “Use my current browser” in the input to fill in your own machine’s UA
  3. Choose the output: a readable report or JSON
  4. Tick "List the matched rules" when you want to see the reasoning
  5. Read the NOTES section — it says what this particular result cannot tell you

FAQ

Can I trust this result?
No. A user agent is written by the client and can say anything: crawlers routinely pretend to be Chrome, and browsers deliberately borrow each other’s tokens. So "what was parsed" tells you what the string says, never what the client actually is. For anything that matters, use capability detection (checking whether an API exists) or User-Agent Client Hints instead of parsing the string.
Why does Edge claim to be Chrome and Safari?
It is a compatibility relic. Sites used to sniff the user agent to decide what to send, so new browsers copied existing tokens to be treated as something recognisable. Edge copied Chrome and Safari; Chrome copied Safari. This tool therefore matches the most specific rule first — Edge before Chrome — and reports how many markers the string actually carries.
Why can it not separate Windows 10 from Windows 11?
Microsoft never changed the NT version number for Windows 11, so both report Windows NT 10.0 — the string genuinely cannot tell them apart, and the result says Windows 10 / 11 rather than guessing. There is a way to find out, though: supply Client Hints. Since Windows 11, Chrome reports a `platformVersion` whose major number jumped to 13 (skipping 11 and 12), so 13.0.0 and up means Windows 11. That is currently the only public signal that separates the two from the browser side, and it is one of the reasons Client Hints exist. macOS behaves the same way: the user agent has been frozen at 10_15_7 since Big Sur, and only the Client Hints `platformVersion` (14.5.0, say) gives the real version.
Why is Brave not detected?
Brave deliberately adds no token of its own; its user agent is byte-for-byte identical to Chrome’s, and several other Chromium-based browsers do the same. That is a design choice on their side, not a gap in this tool.
How is the device type decided?
Mainly from the Mobile token, keywords such as iPad or iPhone, and whether an Android string carries Mobile. One caveat worth remembering: since iPadOS 13, an iPad in desktop mode sends a string identical to a Mac’s, byte for byte — so any macOS result might really be an iPad.
Is the user agent uploaded?
No. Everything runs locally and the page makes no network requests.
What does the “Use my current browser” button fill in?
It fills in the user agent of this very machine (`navigator.userAgent`) — it is not “detecting the other side”; the two directions are opposites. Getting that string by hand means digging through developer tools or typing `javascript:alert(navigator.userAgent)` into the address bar, and many browsers no longer let you paste that. This button skips both steps and parses your own machine’s UA straight away.
How do I get that Client Hints JSON?
Open your browser’s developer console and run `JSON.stringify(navigator.userAgentData)`, then paste the whole output into the Client Hints box above. Not every browser has it: Firefox and Safari have no `navigator.userAgentData`, so the console has nothing to print — leave the box empty there. When it is empty the tool judges from the UA string alone and says so in the result.

Related tools