User-Agent Parser
Parse any user-agent string into browser, OS, device type, and rendering engine - instantly, in your browser.
- Free, no account
- No watermark
- No usage limit
About the User-Agent Parser
Paste a user-agent string and you get the browser and its version, the operating system, whether the thing is a phone, tablet, or desktop, and the rendering engine underneath, all parsed the moment it lands in the box. It opens with your own browser's string already filled in, and it re-parses whatever you paste as you type. Everything happens in your browser tab, so the string never leaves your machine.
The browser field is where most free parsers fall apart, and it's the reason this one exists. Point a lazy parser at an Edge string and it will swear the user is on Chrome. Same story for Opera, Samsung Internet, Brave, Vivaldi. They're all built on Chrome's core, they all carry the entire Chrome token inside their string, and a parser that scans for "Chrome" and stops declares every one of those people a Chrome user. This one checks the impostors first, so Edge comes back as Edge and Opera comes back as Opera. Get it wrong and you end up staring at an analytics chart that insists your traffic is almost all Chrome when a good slice of it never was.
How to use it
- Read your own result first. The box loads with your browser's user agent already parsed into the table below: browser, version, OS, OS version, device type, and rendering engine.
- Paste any other string. Drop in a UA from a log line, a bug report, or a message a colleague sent you. The table updates as you type, there's no button to press.
- Hit one of the sample buttons (Chrome on Windows, Safari on iPhone, Edge, Firefox on Linux, Android, Googlebot) to watch how a known string parses.
- Copy the result to hand off all six fields as plain text for a ticket or a chat.
- Clear wipes the box so you can start over.
Why the order of the checks is the whole trick
A modern user-agent string is almost thirty years of compatibility cruft stacked on top of itself. Chrome's string announces Mozilla, then AppleWebKit, then "like Gecko," then Safari, and only near the very end does it admit it's actually Chrome. Every earlier token is a leftover from an age when some web server sniffed for that exact word before serving the good version of a page, and nobody dares delete any of them, because somewhere a server from 2004 is still checking. Edge, Opera, Samsung Internet, Brave and the rest inherited all of it, then bolted their own name on the end, and that tag (Edg, OPR, SamsungBrowser) is what actually identifies the browser.
So the entire job comes down to reading the honest tags before you ever look for Chrome. A parser that tests for Chrome first stops on the first match and never reads far enough to hit the Edg that would have corrected it. That is exactly how a free tool ends up labeling every Edge, Opera, and Samsung visitor as Chrome and quietly throwing your numbers off. This one runs the checks in the right order, every time, and it screens for bots before it touches a single browser rule. Googlebot, Bingbot, curl, wget, python-requests and the rest come back tagged as automated traffic instead of getting misread as a browser they were never pretending to be. A lot of those bot strings carry a Mozilla prefix on purpose so careless servers wave them through, and catching them up front keeps your device chart clear of phantom users.
And these strings usually come straight out of server logs and private bug reports, which is the real reason parsing stays local here. A lot of the free online parsers take whatever you paste and ship it to their own backend to do the work. Your raw logs, a customer's leaked UA, sent off to a server you know nothing about. This one never does that. It parses in your tab and sends nothing anywhere, so you can drop in a real log line without thinking twice about it.
A user agent is just a claim
A user-agent string is only whatever the browser decided to say about itself, and anyone can rewrite it in one line. curl -A "Googlebot/2.1" makes a terminal claim to be Google. Flip on device emulation in your dev tools and your UA turns into an iPhone. Scrapers lie about this all day long, precisely because so many sites still take the string at face value.
Even when nobody is lying, the string hides things on purpose. Since iPadOS 13, Safari on an iPad reports itself as desktop Safari on a Mac, with no "iPhone" and no "Mobile" token anywhere in sight. As far as the string can tell, an iPad and a MacBook are the same machine. Device type is a best guess and nothing more. An Android string with a "Mobile" token is a phone, the same string without it is a tablet, and that shortcut is right most of the time and wrong exactly when the UA is unusual.
When you genuinely need the truth, the string is the wrong place to look. Newer Chromium browsers send User-Agent Client Hints, a set of small structured headers, and those are the only dependable way to read something like whether a Mac is Apple Silicon. Firefox and Safari don't fully support them yet, so the working approach is to read the hints when they're there and fall back to the string when they aren't. And if you're deciding whether to switch on some browser feature, test for that feature directly instead of the version number, because a version number goes stale the moment the browser updates.
Frequently asked questions
Why does Windows come back as "10 / 11"?
Because the raw string honestly can't tell them apart. Windows 10 and Windows 11 both report Windows NT 10.0. Microsoft never bumped that number for 11, so nothing in the string separates the two. Rather than pick one and be confidently wrong half the time, the tool shows both and leaves the call to you and whatever else you already know about the machine.
What happens if I paste garbage or leave the box empty?
Every field reads "Unknown" and the table just sits there. No crash, no error, no NaN. There are thousands of string variants out in the wild, so when the parser can't confidently name a field it says so instead of inventing an answer. Paste a partial or mangled string and you'll usually get a couple of fields filled in and the rest left Unknown, which is often enough to tell what you're looking at.
The engine says Blink but I'm on Edge. Is that a bug?
No, that's working as intended. Blink is the rendering engine inside Chrome, Edge, Opera, Brave, Samsung Internet and nearly every Chromium browser. The browser name and the engine sit on two different layers. Two differently branded browsers on Blink render a page almost identically, which is why the engine field tells you more than the browser name when you're chasing a layout bug, and Gecko in that field means Firefox.
Two cases are worth knowing, because they are where the browser name stops predicting the engine. Edge came in two completely different browsers wearing one name: versions 12 through 18 ran Microsoft's own EdgeHTML and wrote Edge/ in the string, while version 79 onward is Chromium and writes Edg/ on desktop or EdgA/ on Android. The tool reads the token rather than the name, so an old Edge string comes back as EdgeHTML and a current one as Blink. And on iOS every browser is WebKit, whatever its badge says, because Apple requires it. Chrome on an iPhone is Chrome wrapped around Safari's engine, so it renders like Safari and reproduces Safari's bugs, which is exactly what you need to know when a page misbehaves there and nowhere else.
Can I use this to block bots or gate access?
No, and this is the one that burns people. A user agent is self-reported and spoofable in one line, so it can never confirm identity or keep a determined bot out. Use it to understand your traffic and triage bug reports. For anything that gates access, you need a signal the client can't fake. If you want to know whether something calling itself "Googlebot" really is Google, run a reverse DNS lookup on its IP address, which the client has no control over.
Should I just knock together my own parser with a quick regex?
Only if you enjoy pain. UA parsing looks like a five-minute job and turns into a swamp: thousands of variants, new browsers shipping constantly, embedded webviews, oddball mobile systems, and bots impersonating all of them. For anything running in production, reach for a maintained library like ua-parser-js in JavaScript, or its equivalent in Python or Go, where the patterns get updated as new browsers land. This tool is for a quick manual look at a string in front of you.
Why is the OS version stale or just missing?
Mostly on purpose. Browsers have been freezing the OS version in the string to cut down on fingerprinting, part of a broader move toward a stripped-down "reduced" user agent. Chrome now reports macOS as 10_15_7 for every machine regardless of what it actually runs, and pins the Windows value the same way, so the number you see is a frozen placeholder that no longer tracks the real OS. Treat it as a rough hint at best, and don't wire feature logic to the exact value, it can be years out of date. When you need the true version, read it from the structured Client Hints headers instead.