User Agent Parser

Parse user agent strings to identify browser, OS, and device. Free, fast, and works entirely in your browser with no sign-up required.

Updated

Share:
Home/Utility Tools/User Agent Parser

User Agent Parser

Parse any User Agent string — detect browser, OS, device, engine, CPU, and bots. Compare two UAs, build custom UAs, browse a library of 35+ common agents, explore regex patterns, and view your browser's full fingerprint.

User Agent String

Paste a User Agent string above or click My Browser to detect your current browser.

About User Agent Strings

A User Agent string identifies the browser, OS, and device to web servers. It follows a legacy format: Mozilla/5.0 (OS info) Engine/version Browser/version. The “Mozilla/5.0” prefix is included by virtually all modern browsers for historical compatibility reasons.

Privacy First: All parsing happens locally in your browser. No UA strings are ever sent to any server.

Frequently Asked Questions

What do the parts of a user agent string actually mean?

A user agent string packs several layers into one line. It almost always opens with "Mozilla/5.0", a legacy token nearly every browser still sends for historical compatibility, so it tells you nothing about the real browser. Inside the parentheses sits the platform block: the operating system, its version, and the CPU architecture, such as "Windows NT 10.0; Win64; x64" or "iPhone; CPU iPhone OS 17_1". After that come the rendering engine and its version, like "AppleWebKit/537.36 (KHTML, like Gecko)", followed by the actual browser token, such as "Chrome/120.0" or "Safari/605.1". The parser separates each of these into clean, labelled fields so you do not have to read the raw string. Paste any string above and it splits browser, OS, device, engine, and CPU for you instantly.

How does the parser tell the difference between a mobile phone and a tablet?

It reads device cues from the string rather than guessing from screen size. A phone is flagged when the string contains tokens like "Mobile", "iPhone", "iPod", or "Android" alongside "Mobile". A tablet is detected from "iPad", "Tablet", or — importantly — "Android" without the "Mobile" keyword, because Android tablets drop that word while phones keep it. That single "Mobile" token is the main signal Google and other servers use to separate the two, which is why an Android tablet and an Android phone can otherwise look almost identical. Anything that matches neither pattern is treated as desktop, and recognised crawlers are tagged as bots. Where the model is exposed, such as a Pixel or an SM-series Samsung, the parser surfaces the vendor and model too. Paste a string above to see the device type it resolves to.

Can a user agent string be faked, and how do I verify a bot like Googlebot?

Yes. A user agent string is just a request header, and it can be edited or spoofed freely, so it is evidence rather than proof. Anyone can set their string to claim they are Googlebot, an iPhone, or any browser they like, which is why traffic that looks like a search crawler in your logs may be a scraper wearing a disguise. To confirm a self-declared bot, do not trust the string alone: run a reverse DNS lookup on the visitor's IP, check that it resolves to the crawler's official domain, then do a forward lookup back to the same IP. Google, Bing, and others publish this verification method. The parser flags roughly two dozen known crawlers by name and reminds you to verify them, but the lookup itself is the real test. Paste a suspicious string above to see what it claims to be.

Why does my browser report a rounded or outdated version number?

Modern browsers are deliberately freezing and trimming their user agent strings to reduce fingerprinting and the privacy risk that a highly specific string creates. Chrome and other Chromium browsers now often report a reduced string with a frozen or rounded version — frequently showing only the major version with minor digits zeroed — instead of the exact build number. The detailed values that used to live in the string have moved to User-Agent Client Hints, a separate set of headers a server must explicitly request. So if the parser shows a version that looks rounded or behind your installed build, the string itself is the limitation, not the tool. The Fingerprint tab reads live values straight from your browser's navigator and screen objects to show what is still exposed beyond the string. Click "My Browser" above to load your real string and compare what it does and does not reveal.

What is the difference between the browser, the rendering engine, and the OS in a parsed result?

They answer three separate questions, and the parser reports each on its own line. The browser is the application the person is using — Chrome, Firefox, Safari, Edge, Brave, or Samsung Internet — and it is what most people mean by "what browser is this". The rendering engine is the underlying software that lays out and paints the page: Blink powers Chrome, Edge, Opera, and Brave; WebKit powers Safari; Gecko powers Firefox; Trident powered old Internet Explorer. This is why several different-looking browsers can behave identically — they share an engine. The operating system is the platform underneath both, such as Windows 11, macOS, iOS, or Android, with its own version. Separating these helps you pin down whether a bug is browser-specific or engine-wide. Paste a string above to see all three fields broken out cleanly.

Embed This Tool

Add a free, live version of this widget to your own website or blog post — it runs entirely in your visitors' browsers, with a credit link back to The Toolbox.

Copy & paste this HTML
<iframe src="https://getthetoolbox.com/embed/user-agent-parser" title="User Agent Parser — The Toolbox" width="100%" height="280" style="max-width:480px;border:1px solid #e2e8f0;border-radius:12px" loading="lazy"></iframe>
<p style="font-size:12px;margin:4px 0 0"><a href="https://getthetoolbox.com/utility-tools/user-agent-parser?utm_source=embed&utm_medium=widget" target="_blank" rel="noopener">Free User Agent Parser</a> by The Toolbox</p>

About the User Agent Parser

The User Agent Parser breaks a raw User Agent string down into the browser, operating system, device, rendering engine, and CPU architecture it describes. Paste any UA string, or click My Browser to load your own, and the tool decodes it instantly. Developers, QA testers, SEO specialists, and support teams reach for it whenever a cryptic line like Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 … lands in a log file or a bug report and needs translating into something readable.

Everything runs locally in your browser. UA strings are parsed with on-device pattern matching, and no string you enter is ever sent to a server. Your parse history is kept only in your browser's local storage, there is no sign-up, and nothing is uploaded.

What a User Agent string is and what gets decoded

A User Agent (UA) string is a header a browser sends with every request so a server knows what is asking for the page. It is deliberately dense, layered with legacy tokens like Mozilla/5.0 that almost every browser still includes for historical compatibility. The parser separates the signal from that noise and reports:

  • Browser — name, full version, and major version, recognising Chrome, Firefox, Safari, Edge, Opera, Brave, Vivaldi, Samsung Internet, UC Browser, the iOS variants (CriOS, FxiOS), Amazon Silk, and Internet Explorer.
  • Operating system — Windows (including a 7/8/8.1/10/11 split), macOS, iOS, iPadOS, Android, Chrome OS, Linux, and FreeBSD, with version and platform identifier.
  • Device — type (desktop, mobile, tablet, or bot) plus vendor and model where the string exposes it, such as Apple iPhone, Samsung SM-series, or Google Pixel.
  • Engine and CPU — the layout engine (Blink, WebKit, Gecko, or Trident) and architecture (amd64, arm64, ia32).

It also flags bots: roughly two dozen known crawlers are recognised by name, from Googlebot, Bingbot, and YandexBot to AhrefsBot, SemrushBot, and social fetchers like facebookexternalhit and Twitterbot.

Beyond a single string: compare, build, and reference

The parser is one of seven tabs. Compare places two UA strings side by side and highlights every field that differs, which is useful when a bug reproduces on one device but not another. UA Builder generates a valid string from a chosen browser, OS, and device combination for testing. The UA Library holds 35+ ready-made examples across desktop, mobile, tablet, and bot categories that you can load with one click. A Regex reference lists the detection patterns behind the parser, and History keeps your recent parses, shows a tally of the browsers and operating systems you have looked at, and can export the lot to JSON.

Why it matters, and a note on reliability

Reading UA strings helps you debug device-specific layout issues, confirm whether traffic in your logs is a real visitor or a crawler, and check that analytics are bucketing browsers correctly. The Fingerprint tab goes further, reading live values from your browser's navigator and screen objects, screen resolution, pixel ratio, touch support, language, CPU cores, and more, to show how much a site can learn about you without any UA string at all.

One caveat worth keeping in mind: User Agent strings can be edited or spoofed, so they are evidence, not proof. A line claiming to be Googlebot, for instance, should be confirmed with a reverse DNS lookup before you trust it. Modern browsers are also freezing and trimming their UA strings in favour of Client Hints, so very recent versions may report a rounded number rather than an exact build.

Paste a string above or load your own browser to see the full breakdown, then copy any field or the complete JSON result for your bug report or test suite.