User Agent Parser
Parse a user agent string into browser, OS and device - free, no signup.
This is a best-effort parser covering the major browsers and operating systems, not an exhaustive device database - an unusual or spoofed user agent may not be identified correctly.
What this tool does
Paste a user agent string (or use the box pre-filled with your own browser's) and it's parsed into the browser and version, operating system and version, device type (desktop, mobile or tablet), and rendering engine. The checks are ordered carefully so that Chromium-based browsers like Edge and Opera - which both include 'Chrome' in their own user agent string - are identified correctly rather than being misreported as Chrome.
Parses a user agent string into browser name and version, operating system and version, device type, and rendering engine.
Correctly distinguishes Chromium-based browsers (Edge, Opera, Samsung Internet) from plain Chrome, since they all include 'Chrome' in their own UA string.
Is pre-filled with your own browser's live user agent string, so you can see your own result immediately.
Recognises the rendering engine behind the browser too - Blink, Gecko, WebKit or Trident - alongside the browser name itself.
Includes ready-made example strings for Chrome on Windows, Safari on iPhone and Firefox on Linux, so you can see how different platforms parse without needing your own device to test from.
How to use it
- Paste a user agent string, or use the one already filled in from your own browser.
- Read off the parsed browser, OS, device and engine.
Why use this parser
User agent strings are long and cluttered with legacy tokens. Parsing them shows the browser, system and device at a glance for support and analytics.
Why we built it
We built the user agent parser to check the specific tokens of Chromium-based browsers (Edg, OPR, SamsungBrowser) before falling back to Chrome, so Edge is not reported as Chrome. Check a screen with the screen resolution checker and look at addresses with the IP subnet calculator.
For a neighbouring job there is also the MIME Type / File Extension Lookup and the HTTP Status Code Lookup.
Who this tool is for
- Developers and QA testers reading server logs
- Support staff diagnosing a browser or device issue
- Analysts classifying traffic
When to use it
- Debugging browser-specific issues.
- Reading analytics or log entries.
- Checking what a device reports.
- Understanding a support request.
Why detection order matters
Several browsers deliberately claim to be Chrome, for compatibility.
Microsoft Edge, Opera, Samsung Internet and several other browsers are built on the same Chromium engine as Google Chrome, and for compatibility with sites that only check for 'Chrome', their user agent strings include the word 'Chrome' too - alongside their own identifying token (Edg/, OPR/, SamsungBrowser/). A parser that checks for 'Chrome' first, without first checking for those more specific tokens, will misidentify every Edge and Opera visitor as Chrome. This tool checks the more specific browser tokens first, falling through to plain Chrome only when none of them match.
Why UA parsing is inherently a best-effort guess
There's no authoritative registry behind a user agent string - only convention.
Unlike a file format or a network protocol, there is no single governing specification that fixes what a user agent string must contain or in what order - each browser vendor writes its own, largely by copying and extending the conventions earlier browsers established (which is exactly why modern Chrome, Edge and Safari user agents all still contain the string 'Mozilla/5.0', a decades-old compatibility fossil). Because there's no formal registry, a parser has no choice but to work from an evolving list of known patterns and tokens rather than validating against a fixed spec - a brand-new browser, an unusual embedded webview, or a vendor's new naming convention can all produce a string this tool's pattern list doesn't yet recognise, in which case the affected field falls back to 'Unknown' rather than a wrong guess.
A user agent string is also fully client-controlled: a visitor's browser extension, developer tools, or a script can rewrite it to say anything. This tool - like any UA parser - reports what the string claims, not a cryptographically verified fact about the actual software making the request.
What you give it, and what you get back
| Item | Details |
|---|---|
| Input | A user agent string, or your own. |
| Output | Browser and version, operating system, device type and engine. |
| Notes | Best-effort parsing. |
Issues you may run into
| What you see | Why it happens | What to do |
|---|---|---|
| Result is wrong | The string is unusual or spoofed. | Treat it as indicative. |
| Chrome shows as Edge | Chromium browsers share tokens; Edge is detected specifically. | This is correct. |
| Browser reports less detail | Browsers freeze parts of the string. | Use feature detection in code. |
Assumptions and limitations
- This is a best-effort parser covering the major, widely-used browsers and operating systems - an unusual, very old, or deliberately spoofed user agent string may not be identified correctly.
- A user agent string can be changed by the visitor or their browser's developer tools at will; this tool reports what the string claims, which isn't a guaranteed proof of the actual software in use.
Frequently asked questions
How do I parse a user agent string online for free?
Paste the string (or use the one pre-filled from your own browser) and it's parsed instantly into browser, OS, device type and engine.
Why do some tools misidentify Edge or Opera as Chrome?
Because those browsers include the word 'Chrome' in their own user agent for compatibility - a parser needs to check for their more specific identifying tokens (like Edg/ or OPR/) first, or it will misreport them.
Can this tell me if a visitor is on mobile or desktop?
Yes - device type (Desktop, Mobile or Tablet) is one of the four things parsed out, alongside browser, OS and rendering engine.
Is a user agent string a reliable way to detect a browser?
It's a reasonable signal but not a guarantee - a user agent string can be changed by the visitor or their browser's own developer tools, so it reports what's claimed, not a verified fact.
Is my data uploaded anywhere?
No. Parsing happens entirely in your browser - nothing is sent to a server, and closing the tab clears it.
Why is there no official standard for user agent strings?
Because no governing spec ever fixed their format - each browser vendor writes its own, mostly by copying earlier browsers' conventions (which is why virtually every modern browser's UA string still starts with the decades-old 'Mozilla/5.0'). Parsers work from an evolving list of known patterns rather than validating against a fixed standard.
What does the rendering engine field actually tell me?
Which underlying engine renders the page for that browser - Blink (Chrome, Edge, Opera), WebKit (Safari), Gecko (Firefox) or Trident (old Internet Explorer). Browsers sharing an engine tend to render web pages very similarly, even with different names and UIs.