RunLocalTools

User-Agent Parser

Paste a raw user-agent string and get it broken down into readable fields — browser name and version, operating system, device type, and rendering engine — instead of squinting at a cryptic single line of text.

Why a user-agent string looks like nonsense at first glance

A real user-agent string, something like Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36, is a genuinely strange piece of internet history — it’s packed with legacy identifiers left over from decades of browser one-upmanship (nearly every browser claims to be “Mozilla” and “like Gecko” for backward-compatibility reasons that have nothing to do with what browser it actually is). Reading one accurately without a parser means knowing which tokens actually matter and which are vestigial noise, which isn’t something worth memorizing when a parser can do it instantly.

How to use it

  1. Paste a full user-agent string into the input field — copied from browser dev tools, an analytics log, a server access log, or a support ticket.
  2. Get an immediate structured breakdown: browser name and exact version, operating system and version, device type (desktop, mobile, tablet), and rendering engine (WebKit, Gecko, Blink).
  3. See your own current browser’s user-agent string pre-filled automatically as a working example, useful for understanding the format before pasting an unfamiliar one.
  4. Use bulk mode to paste a list of user-agent strings (one per line, common when pulled from a server log) and get a parsed table of all of them at once, rather than one at a time.
  5. A raw token breakdown panel shows exactly which part of the original string mapped to each parsed field, useful when you’re trying to understand the format itself rather than just getting the end result.

Common situations this solves

  • Debugging a browser-specific bug report, confirming exactly which browser version and OS a user was on when an issue occurred, especially when the report itself is vague.
  • Analyzing server or analytics logs to understand your actual visitor browser/device breakdown, when the raw data is just a column of unparsed user-agent strings.
  • Verifying how your own application’s user-agent detection logic is classifying a given browser, by comparing against this tool’s independent parsing as a sanity check.
  • Investigating suspicious or bot traffic, since malformed, outdated, or unusually generic user-agent strings are often (though not definitively) a signal of automated rather than human traffic.
  • Understanding legacy code that branches behavior based on user-agent sniffing, by decoding exactly what conditions in an old codebase were actually checking for.

Frequently asked questions

Why do almost all browsers include “Mozilla” in their user-agent string, even browsers that have nothing to do with the original Mozilla/Netscape?

This is a genuine historical artifact — in the era of the 1990s browser wars, websites checked for “Mozilla” in the user-agent to decide whether to serve enhanced features, so every subsequent browser (Internet Explorer, Chrome, Safari) started including “Mozilla/5.0” purely for backward compatibility with that old detection logic, and the convention simply never went away even though the check itself is obsolete.

Can a user-agent string be spoofed or faked?

Yes, trivially — browsers allow user-agent strings to be manually overridden (often intentionally, for testing how a site behaves on a different device), and some tools or scripts deliberately fake a user-agent to appear as a different browser or bypass basic bot detection. This means user-agent parsing should be treated as a useful signal rather than a fully trustworthy source of truth, particularly for anything security-sensitive.

Why does the parser sometimes show “unknown” for certain fields?

This usually happens with unusual, custom, or heavily modified user-agent strings (some privacy-focused browsers deliberately genericize their user-agent, and some bots/scripts use minimal or malformed strings) that don’t match any recognized standard pattern — an “unknown” result is itself informative, since it suggests the traffic may not be from a mainstream browser behaving normally.

Is user-agent detection still a reliable way to determine what device someone is using?

It’s become progressively less reliable over recent years — major browsers have begun “freezing” or genericizing parts of their user-agent strings for privacy reasons, meaning some fields that used to reveal precise OS versions now report more generic values by design. For modern feature detection, most developers are moving toward checking actual browser capabilities directly rather than inferring them from the user-agent string.

Does this tool store or log the user-agent strings I paste in?

No — parsing happens entirely in your browser using pattern-matching logic, and nothing you paste is transmitted anywhere, which matters since user-agent strings pulled from real server logs can sometimes appear alongside other data you wouldn’t want uploaded to a third party.