Skip to main content
L
Loopaloo
Buy Us a Coffee
All ToolsImage ProcessingAudio ProcessingVideo ProcessingDocument & TextPDF ToolsCSV & Data AnalysisConverters & EncodersWeb ToolsMath & ScienceGames
Guides & BlogAboutContact
Buy Us a Coffee
L
Loopaloo

Free online tools for developers, designers, and content creators. Your files are processed in your browser and are never uploaded - no accounts required. A few network utilities (like What's My IP and Currency Converter) call public APIs to do their job and say so on their pages.

support@loopaloo.com

Tool Categories

  • Image Tools
  • Audio Tools
  • Video Tools
  • Document & Text
  • PDF Tools
  • CSV & Data
  • Converters
  • Web Tools
  • Math & Science
  • Games

Company

  • About Us
  • Contact
  • Blog
  • FAQ

Legal

  • Privacy Policy
  • Terms of Service
  • Disclaimer

Support

Buy Us a Coffee

© 2026 Loopaloo. All rights reserved. Built with privacy in mind.

Privacy|Terms|Disclaimer
  1. Home
  2. Web Tools
  3. User Agent Parser
Add to favorites

User Agent Parser

Read a user agent string and mark every field: read from a token, a frozen constant, or something the string cannot answer at all.

Runs locally in your browserMore web toolsJump to full guide

Initializing in your browser…

You might also like

Robots.txt Generator

Write a robots.txt by the RFC 9309 rules, then test a URL against it and see which rule wins and why.

URL Safety Analyzer

Check a link for typosquats, brand-in-subdomain tricks, mixed-alphabet homographs, and hidden destinations. Public Suffix List parsing, explainable per-rule scoring, and the link is never fetched.

Certificate Decoder

Decode an X.509 certificate field by field, check which host names it covers, and verify that each certificate in a chain was signed by the one above it

User Agent Parser: a worked example

A bug reproduces only for one customer. Their ticket carries a raw User-Agent header, and you need to know which browser to open before you can chase it.

The raw User-Agent header

Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X)
  AppleWebKit/605.1.15 (KHTML, like Gecko)
  CriOS/120.0.6099.119 Mobile/15E148 Safari/604.1
What User Agent Parser produces

What each field is, and where it came from

Browser   Chrome 120.0.6099.119        read     CriOS/120.0.6099.119
OS        iOS 17.2                    read     iPhone OS 17_2
Engine    WebKit                      inferred
CPU       Unknown                     not in the string
Device    Apple iPhone, mobile

Every token, and what it means:
  Mozilla/5.0                       dates from Netscape, means nothing
  iPhone                            the model is never in the string
  CPU iPhone OS 17_2 like Mac OS X  the iOS version; "like Mac OS X"
                                    is for old sniffers and is not macOS
  AppleWebKit/605.1.15              a real WebKit version
  KHTML, like Gecko                 carried since 2003
  CriOS/120.0.6099.119              the browser: Chrome 120.0.6099.119
  Mobile/15E148                     a frozen iOS build number
  Safari/604.1                      a real Safari build number

Three answers here are ones a keyword parser gets wrong, and all three change what you would go and test.

There is no Chrome token in this string. Chrome on iOS writes CriOS, so a parser looking for "Chrome" finds nothing and reports the browser as Unknown, or falls through to the Safari branch and reports Safari. The same applies to FxiOS, EdgiOS and OPT.

The words "like Mac OS X" appear in every iOS string, put there for sniffers written in 2007. A macOS test that runs before the iOS test matches them, so a naive parser reports every iPhone and every iPad as a Mac. That is why the order of tests here puts iOS and iPadOS first, and why the token breakdown says outright what the phrase is for.

The engine is WebKit, and here that is the truth rather than the usual fiction. App Store rules require every browser on iOS to use the system engine, so Chrome on iOS really is WebKit. On the desktop the same token means the opposite: every Chromium browser sends AppleWebKit/537.36 and Safari/537.36 while running Blink, so reading the engine off the token there gets it wrong for Chrome, Edge, Opera, Brave, Vivaldi and Samsung Internet at once.

The CPU line is worth as much as the others. The string does not carry the architecture, so nothing is reported, rather than a guess being dressed up as a reading. Every field on the page carries a badge saying whether it was read from a token, is a frozen constant that says nothing about the machine, or is simply absent.

What the string says, and what it cannot say

Paste a user agent string and every field comes back marked with where it came from: read from a token, a frozen constant that says nothing about the machine, or something the string simply cannot answer. Chrome on iOS is named as Chrome, an iPhone is not called a Mac, and every Chromium browser is reported as Blink rather than as the WebKit its own string claims.

Key features

  • The engine derived from the browser, so every Chromium build is Blink rather than the WebKit its string claims
  • CriOS, FxiOS, EdgiOS and OPT named, with iOS put ahead of macOS so an iPhone is not reported as a Mac
  • Frozen fields marked as frozen: macOS 10.15.7, Windows NT 10.0, and the reduced Android string's Android 10 and model K
  • The Chromium base version shown separately from the browser version for Samsung Internet, Edge, Opera and Vivaldi
  • A comparison against navigator.userAgentData, the only reference that is not another parser
  • Crawlers matched on the token each one publishes, including facebookexternalhit and the AI crawlers
  • Libraries and command line clients identified by the RFC 9110 product/version form rather than called desktop browsers
  • Every token broken out by the RFC 9110 grammar with what it means
  • A caveat list per string, saying what that particular string cannot answer
  • Nothing is transmitted; the string is parsed in your browser and never reaches the URL

How to use

  1. 1Your own string is loaded automatically. Press "Use this browser" to get it back after pasting another.
  2. 2Read the badge on each field: read means a token said so, frozen means the string carries a constant, and "not in the string" means nothing here will guess.
  3. 3Read "What this string cannot tell you" before acting on anything.
  4. 4On a Chromium browser, compare your own string against what the browser reports about itself.
  5. 5Try the sample buttons: each one is a real published string chosen because it breaks a different assumption.

A user agent string is a compatibility artefact, not a description of a machine

Almost every token in a user agent string is there because some site once sniffed for it, and the three biggest consequences are the reason most parsers get the same three things wrong.

The first is the engine. Every Chromium browser sends "AppleWebKit/537.36 (KHTML, like Gecko)" and "Safari/537.36" and has done since 2013, while its engine is Blink. A parser that reads the engine off the AppleWebKit token calls Chrome, Edge, Opera, Brave, Vivaldi and Samsung Internet WebKit, which is exactly the mistake the token was put there to cause. Here the engine is derived from the browser instead, and the reason is printed next to the answer.

The second is iOS. App Store rules require every browser on iOS to use the system engine, so Chrome is CriOS, Firefox is FxiOS, Edge is EdgiOS and Opera is OPT. None of them contains a Chrome token at all, and all of them contain "like Mac OS X", which is what makes a naive macOS test match first and report every iPhone in the world as a Mac. The order of tests here puts iOS and iPadOS ahead of macOS for that reason, and each of the four browsers is named rather than falling through to Safari or to Unknown.

The third is that several fields are frozen and carry a constant whatever the machine is. macOS has reported 10_15_7 in the user agent string for every version since Big Sur, so the number says nothing. Windows 11 reports "Windows NT 10.0" exactly as Windows 10 does, because Microsoft did not raise the NT version, so a tool that tells you which one you are on is guessing. Chrome's reduced user agent sends "Android 10" and the device model "K" on every Android device there is, and zeroes the minor, build and patch of its own version. Each of those is labelled frozen rather than reported as a reading, and the page says what the constant is and why.

Where the string cannot answer, the browser itself sometimes can. navigator.userAgentData is the browser answering the same questions about itself in structured form, and on a Chromium build it carries the real platform version, the device model and the CPU architecture. That is the only reference a user agent parser can be checked against that is not another parser, so when the box holds your own browser's string the two are shown side by side with the disagreements marked. On the machine these tests run on, the string says macOS 10.15.7 and the browser says macOS 26.6.2, and the string cannot give the architecture at all while the browser reports ARM64. Safari and Firefox declined to implement the API, and the page says so rather than leaving the panel blank.

Non-browser clients are the other half. A keyword list built from bot, crawl, spider, slurp, search, fetch and archive misses facebookexternalhit, curl, python-requests, Go-http-client and okhttp, which between them account for a great deal of what actually hits a server. Named crawlers are matched on the token each one publishes, including the AI crawlers that appeared recently, and anything left that writes the product/version form RFC 9110 section 10.1.5 describes without opening with Mozilla is reported as a library rather than as a desktop browser.

Finally, the whole string is broken up by the RFC 9110 grammar rather than on whitespace, so "Windows NT 10.0" stays one item instead of three, and each piece is shown with what it means. Above all of it sits the fact that decides how much any of this is worth: a user agent string is whatever the client chose to send. Nothing measures it, every browser lets an extension change it, and a crawler that wants to look like a person simply writes a browser string.

Examples

  • Chrome on iOS

    A CriOS string has no Chrome token at all and says "like Mac OS X". The page names Chrome, reports iOS rather than macOS, and gives the engine as WebKit because iOS requires the system engine.

  • Samsung Internet

    The string carries SamsungBrowser/23.0 and Chrome/115.0.0.0. The browser is Samsung Internet 23; the Chrome number is the Chromium version it is built on, and both are shown with a line saying which is which.

  • A reduced Android string

    Chrome sends "Android 10; K" on every Android device. The version is marked frozen and the model is not reported at all, because K is a constant rather than a device.

  • facebookexternalhit

    The Facebook link fetcher contains none of the usual crawler keywords, so keyword lists miss it. It is matched on its own token and reported as a crawler.

Tips & best practices

  • The badge matters more than the value. A frozen field is a constant, not a reading.
  • If you need the real Windows version, the real macOS version or the real Android model, only Client Hints has them, and a site has to ask for the high entropy values.
  • Brave ships the plain Chrome string on purpose. If a report says Chrome, some of it is Brave and nothing can separate them.
  • iPadOS sends the Macintosh string by default, so iPad traffic shows up as macOS in every analytics tool.

Practical scenarios

  • Working out why analytics disagree with reality

    iPad traffic reads as macOS, Brave reads as Chrome, and every Android device reads as Android 10. The page names each of those rather than presenting the number as a fact.

  • Debugging a client-specific bug from a log line

    Paste the User-Agent header and see the browser, the engine and which parts of the string were constants rather than readings.

  • Telling a crawler from a person

    Named crawlers, AI crawlers and library clients are identified separately, and anything that is not identifiable is said to be not identifiable rather than called a desktop browser.

  • Checking a parser you already use

    On a Chromium browser, compare the string against navigator.userAgentData and see exactly which fields the string gets wrong about the machine it came from.

Frequently asked questions

Why is my Chrome reported as Blink when the string says AppleWebKit?

Because the string is lying, on purpose. Every Chromium browser has sent AppleWebKit/537.36 and Safari/537.36 since 2013 so that sites sniffing for WebKit would serve it the right code. The engine is Blink. Reading the token instead of the browser is the single most common error a user agent parser makes.

Can this tell Windows 11 from Windows 10?

No, and nothing can from the string. Microsoft did not raise the NT version, so both report Windows NT 10.0. Client Hints can answer it: a platformVersion of 13 or higher means Windows 11.

Why does my Mac say 10.15.7?

Because Safari and Chrome froze the number there. Every macOS from Big Sur onward reports 10_15_7 in the user agent string, and Firefox reports 10.15. The real version is not in the string at all.

Why does an Android string say Android 10 and model K?

Those are constants in Chrome's reduced user agent, sent by every Android device regardless of what it is. The real version and model are in the Client Hints platformVersion and model fields, and a site has to ask for them.

Can I trust any of this?

Only as far as you trust the client. A user agent string is whatever the client decides to send: nothing measures it, every browser lets an extension change it, and a crawler that wants to look like a person simply writes a browser string. Use feature detection for anything that matters.

Why is Brave reported as Chrome?

Brave removes its own token deliberately, so its string is identical to Chrome's. No parser can separate them, and one that claims to is guessing. The page says so on every plain Chrome string.

What is navigator.userAgentData?

The User-Agent Client Hints API: the browser answering the same questions in structured form, with the real platform version, device model and architecture behind a permission-like request for the high entropy values. Only Chromium browsers implement it; Safari and Firefox declined.

Private by design

This runs as client-side JavaScript. Keys, tokens, payloads, and other inputs never leave your device.