Home › All Tools ›

User Agent Parser

Use User Agent Parser online for free at FreeToolZones — no sign-up, no watermark.

Loading tool...

Every web request carries a user agent string: a compact, cryptic line of text in which a browser announces itself, its rendering engine, its operating system, and hints about the device it runs on. The string is a historical patchwork, full of legacy tokens that survive for compatibility, and reading it by eye is an exercise in guesswork. The User Agent Parser on FreeToolZones decodes that line into a clear table: browser, version, engine, operating system, device type, device model, and whether the visitor looks like a bot.

This guide explains how the parser reads a user agent string, which browsers and systems it recognizes, and how to interpret results that say Unknown. It also covers the honest limits of user agent detection in an era of frozen strings and deliberate spoofing, with practical examples from debugging, analytics, and support work. If you need to understand what a user agent string really claims, this page shows you how to read it.

What Is the User Agent Parser?

The User Agent Parser is a free online tool that analyzes a user agent string and reports the browser, operating system, device, and bot characteristics it indicates. A user agent string is sent by browsers and other clients in the User-Agent header of every HTTP request, and it is also available to web pages through the browser navigator object. Servers and scripts have used it for decades to adapt content, record analytics, and diagnose problems, even though the format was never formally standardized and grew by imitation and compatibility hacks.

The parser works by pattern matching. It checks the string against a sequence of browser patterns in a careful order, because many user agent strings contain several browser names for compatibility: a Chrome-based browser, for example, typically mentions Chrome, Safari, and Mozilla in the same string. Checking Edge before Chrome, and Chrome before Safari, ensures the most specific match wins. Operating system patterns, device patterns, and a bot keyword check run alongside the browser detection. The result is a table with eight rows: browser, browser version, rendering engine, operating system, OS version, device type, device or model, and a yes-or-no bot judgment.

For convenience, the input box is pre-filled with your current browser user agent string, and the tool parses it automatically when the page loads, so you see your own result immediately. A button restores your browser string at any time after you have pasted a different one. The result carries an explicit caution: detection uses pattern matching, user agent strings can be spoofed, and browser vendors are reducing the detail they include, so results are best-effort. That caution is essential context for every use of the tool, and this guide returns to it throughout.

  • Automatic self-detection: your own browser string is filled in and parsed on load.
  • Eight-field result table: browser, version, engine, OS, OS version, device type, model, and bot status.
  • Ordered browser matching: specific browsers are checked before the generic names they also mention.
  • Bot keyword detection: common crawler and bot tokens are recognized.
  • Device classification: desktop, mobile, and tablet are distinguished from device tokens.
  • Best-effort honesty: the result states that detection is pattern-based and spoofable.

How to Use the User Agent Parser

The widget has one large input box and three buttons. Your own user agent string is already present when the page loads. Follow these steps to parse any string.

  1. Review the automatic result for your browser. When the page loads, the input box contains your current browser user agent string, and the result table appears below the buttons without any click. Read the eight rows to see how your browser presents itself. This immediate result also demonstrates the output format before you paste anything else.
  2. Paste a different user agent string to parse it. Replace the contents of the field labeled User agent string with any user agent string, copied from a log, a support ticket, documentation, or a test case. Paste the complete string, including all tokens and version numbers, because the parser relies on the full text to distinguish similar browsers.
  3. Click Parse user agent. Press the Parse user agent button. If the input box is empty, the tool asks you to paste a string first. Otherwise, the result table appears with the detected values. Unknown values are shown as Unknown or with a dash, which means no pattern in the parser matched that aspect of the string.
  4. Read the result table row by row. Check the browser and version first, then the rendering engine, then the operating system and its version. The device type row says Desktop, Mobile, or Tablet, and the device row names a model when one can be inferred, such as iPhone, iPad, a Pixel model, a Samsung model, a Windows PC, or a Mac. The final row says Yes or No for whether the string looks like a bot or crawler.
  5. Restore your own string when needed. Click the button labeled Use my browser user agent to refill the input box with your current browser string. This is useful after parsing several pasted strings, when you want to compare them with your own or start fresh. If no user agent string is available in the browser, an error message says so.
  6. Clear and parse the next string. Click Clear to empty the input box and remove the result, then paste the next string and parse it. Each parse is independent, and the result always reflects the string currently in the box.

When comparing strings from different sources, parse them one at a time and note the results, because the tool shows one result at a time and keeps no history. A small table of your own, with the string and the parsed fields, makes comparison across many samples practical.

Key Features of the User Agent Parser

The parser recognizes a defined set of browsers, engines, operating systems, and device signals. Knowing the list prevents over-interpreting a result: a browser outside the list may be reported under a generic name, and an operating system outside the list may be reported as Unknown.

  • Browser detection order. The parser checks Microsoft Edge first, then Opera, Samsung Internet, Vivaldi, and Brave, all of which embed Chromium tokens, then Firefox, Firefox on iOS, Chrome on iOS, Chrome, Safari, and Internet Explorer, including the Trident-based version 11 form. If none of those match, it falls back to the first name-and-version token in the string. This order is what prevents an Edge string from being misreported as Chrome.
  • Rendering engine inference. The engine is inferred from the browser match: Blink for Chromium-based browsers, Gecko for Firefox, WebKit for Safari and for browsers on iOS, where the platform requires WebKit, Trident for Internet Explorer, and Presto for older Opera strings without Chromium tokens. The engine row therefore reflects the browser family rather than a separately detected token.
  • Operating system detection. Windows versions are mapped from NT version numbers to familiar names, so NT 10.0 is reported as 10 or 11, reflecting that both share the number, and older numbers map to 8.1, 8, 7, Vista, XP, and 2000. Android, iOS, macOS, ChromeOS, and Linux are detected from their characteristic tokens, with version numbers extracted and underscores converted to dots where applicable.
  • Device type classification. A string mentioning iPad, or Android without the Mobile token, is classified as a tablet. Strings mentioning mobile, phone, or handheld tokens are classified as mobile. Everything else defaults to desktop. This heuristic follows common conventions, but it cannot be certain: device makers and browsers do not always include reliable device tokens.
  • Device and model inference. The model row names iPhone and iPad directly, extracts Pixel model names and Samsung model codes, infers Android model names from the build token, and falls back to Windows PC for Windows strings and Mac for Macintosh strings. When no model signal exists, the row shows a dash. Model inference is the least reliable part of the output and should be treated as a hint.
  • Bot detection keywords. The bot check searches for tokens associated with crawlers and automated clients, including bot, crawler, spider, and the names of well-known search, social, and messaging crawlers. A match sets the bot row to Yes. The check is keyword-based, so a browser string that happens to contain such a token, or a bot that hides its identity, can produce a wrong answer in either direction.
  • Unknown handling. When no pattern matches, the tool reports Unknown or a dash rather than guessing. An Unknown browser with a recognized operating system, for example, usually means an uncommon client, a custom application, or a heavily modified string. Treat Unknown as information, not as failure.

Practical Use Cases for the User Agent Parser

User agent parsing supports debugging, support, analytics review, and testing. The examples below show where parsed results help, and where they must be handled with care.

Debugging browser-specific problems

When a user reports that a page looks wrong or a feature fails, the user agent string identifies the browser, version, and operating system involved. Parsing the string from a support ticket tells you whether the problem is specific to one browser family, one version, or one platform, and lets you reproduce it in the matching environment. Always confirm the diagnosis by testing, because the string alone does not prove the browser actually behaved in the expected way.

Reviewing analytics and log samples

Analytics reports aggregate user agent data into browser and device breakdowns. Parsing individual strings from logs helps you understand the raw data behind those aggregates, spot misclassified traffic, and recognize bot traffic that inflates counts. The bot row is a useful first filter, though dedicated bot detection uses many more signals than the user agent string alone.

Testing responsive and adaptive behavior

Developers test how a site responds to different device types by examining user agent strings from phones, tablets, and desktops. Parsing sample strings confirms which tokens trigger each device classification in this parser, which informs how server-side or script-based adaptation might classify the same strings. Prefer feature detection and responsive design over user agent branching for production behavior, and use parsing mainly for diagnosis.

Identifying crawler traffic

Search engine crawlers, social media preview bots, and monitoring services announce themselves in user agent strings. Parsing a suspicious string quickly shows whether it carries crawler tokens, which explains unusual request patterns, such as rapid page fetching or requests without typical browser headers. A bot judgment of Yes supports, but does not prove, that the traffic is automated, because strings can be copied.

Supporting users with accurate questions

Support teams ask users for their browser and operating system, and users often answer imprecisely. Asking for the user agent string, or reading it from a diagnostic page, gives exact version information. Parsing it here turns that string into a plain-language answer that support staff can record and act on, without asking the user to navigate browser menus.

Learning how browsers identify themselves

The history of user agent strings is a lesson in compatibility: every browser claims to be Mozilla, most claim to be Safari, and Chromium browsers carry a stack of legacy tokens. Parsing your own string and comparing it with strings from other browsers reveals this layering and explains why detection order matters. It also shows why the string is a poor foundation for critical decisions.

Tips and Best Practices

  • Never make security decisions from the user agent string. The string is supplied by the client and can be changed freely. Authentication, authorization, and access control must never depend on it. Use it for display, logging, and diagnosis only.
  • Prefer feature detection in code. When adapting behavior, test whether the browser supports the needed feature rather than branching on the browser name. Feature detection survives new browser versions and new browsers, while name-based branching breaks every time the landscape changes.
  • Expect reduced detail over time. Browser vendors are freezing and reducing user agent detail to protect privacy, replacing precise versions and platform details with coarse values and client hints. Results that say Unknown or show generic versions will become more common. Design systems to cope with missing detail rather than assuming it will always be present.
  • Copy the complete string. Truncated strings lose the tokens that distinguish similar browsers. Copy from the original source, including parentheses and version numbers, and check that the string was not wrapped or cut by the display that showed it.
  • Corroborate bot judgments. A Yes in the bot row is a keyword signal, not proof. Confirm with request patterns, reverse DNS, and behavior before blocking or special-casing traffic. Blocking on the user agent string alone harms legitimate users whose strings contain bot-like tokens and misses bots that impersonate browsers.
  • Treat model names as hints. Device model inference depends on tokens that many strings omit or generalize. Do not present an inferred model to a user as a confirmed fact, and do not make support decisions that depend on the exact model without independent confirmation.

Limitations of the User Agent Parser

The parser recognizes a fixed set of browsers, operating systems, and patterns. New browsers, uncommon clients, embedded web views, and heavily customized strings may be reported as Unknown or under a generic fallback name. Version numbers are extracted from the matched token and may be frozen or reduced by the browser vendor, so a reported version may not reflect the true browser version. The parser does not use client hints, feature detection, or any other signal: it reads only the string you provide.

Bot detection is keyword-based and can be wrong in both directions. Device classification uses heuristics that cannot distinguish every form factor, especially for Android devices and hybrid laptops. The tool parses one string at a time, keeps no history, and does not fetch or analyze the headers of a live request. Most importantly, every result is best-effort, as the tool itself states: user agent strings can be spoofed, and vendors are reducing their detail. Use parsed results as supporting evidence, never as sole proof.

Frequently Asked Questions

Why does my browser string mention several browsers?

For historical compatibility. Browsers include Mozilla, Safari, and other legacy tokens so that old websites, which checked for those names, treat them as supported browsers. The parser checks specific browsers first so the most specific match wins over the legacy tokens.

Why is my browser version reported as Unknown?

Either the string does not match any browser pattern in the parser, or the matched pattern does not include a version number the parser can extract. Uncommon browsers, custom clients, and frozen user agent strings commonly produce this result. The string itself may still contain useful information in its other tokens.

Can a user agent string be faked?

Yes, easily. Any client can send any string it chooses, and browsers offer developer tools to override the string. That is why the tool warns that results are best-effort and why security decisions must never rely on the string.

What does the bot row mean?

It reports whether the string contains keywords associated with crawlers and automated clients. Yes means the string looks like a bot; No means no such keyword was found. Both answers are heuristic: a bot can hide its keywords, and a legitimate string can contain one by coincidence.

Why is Windows 10 and 11 shown together?

Both Windows 10 and Windows 11 report the same NT version number, 10.0, in their user agent strings. The parser maps that number to 10 or 11 because the string alone cannot distinguish them. More precise identification requires client hints or other signals.

Is my user agent string sent anywhere?

No. Parsing happens in your browser. The pre-filled string comes from your own browser navigator object and stays on your device. Pasted strings are analyzed locally and are not uploaded or stored.

Related Tools

These related tools inspect network identity, decode encoded data, and test patterns in text. Browse the full collection from the FreeToolZones home page.

  • IP Address Lookup – analyze the IP address associated with a request or log entry.
  • JWT Decoder – inspect tokens that travel with requests alongside user agent strings.
  • Regex Tester – test patterns for extracting tokens from user agent strings.
  • Base64 Decoder – decode encoded values found in headers and logs.
  • URL Decoder – decode URLs recorded with request data.

Browse More Tools