Ttooleras
🔍

User Agent Parser

Web Tools

Parse User-Agent strings to identify browser, version, operating system, device type, and rendering engine for logs and analytics.. Free, private — all processing in your browser.

Advertisement

Paste a User-Agent string and this breaks it into the four things you usually care about: browser and version, operating system, device type (desktop, mobile, tablet, or bot), and rendering engine. It loads your own browser's User-Agent automatically, so you can see how you appear to a server right away, or paste one from a log to identify a visitor.

User-Agent strings are notoriously messy — a Chrome UA still contains the words "Mozilla", "AppleWebKit", "KHTML", "like Gecko", and "Safari" for historical compatibility reasons. That's why reading them by eye is error-prone. This pulls out the parts that actually matter and labels them, so you don't have to remember which token means what.

It's most useful for quick debugging: checking what a request in your server logs came from, confirming your own browser identity, or sanity-checking device detection. For anything you rely on in production, treat the result as a best guess — see the notes below on why User-Agent parsing is fundamentally unreliable.

Features at a glance

Browser, OS, device, engine

Parses all four components from any modern User-Agent string with version details.

Bot detection

Identifies known crawlers (Googlebot, Bingbot, etc.) and generic bot indicators.

Mobile/tablet/desktop

Classifies device type including handling for iPad requesting desktop UA.

Version accuracy

Extracts browser and OS version numbers where possible, with fallbacks for reduced UAs.

Batch mode

Paste many User-Agents (one per line) and parse them all at once with a summary table.

Compatibility with major parsers

Uses similar patterns to UAParser.js so results match Google Analytics and other analytics tools.

Rendering engine detection

Identifies Blink, Gecko, WebKit, Trident engines for compatibility debugging.

Client-side only

No upload — User-Agent strings from server logs stay local.

Under the hood

Parsing is done with a set of ordered regular expressions in your browser. Browser detection checks in a deliberate order — Edge (Edg/), Opera (OPR/), then Firefox, Chrome, Safari, and Internet Explorer — because their tokens overlap. Edge and Opera both include "Chrome" in their strings, so they must be matched first or they'd be misidentified as Chrome. Version numbers are captured from the matching token.

OS detection maps the familiar markers: Windows NT 10 (which covers both Windows 10 and 11 — Microsoft never bumped the NT version), Android and iOS with their version numbers, macOS (with underscores converted to dots), and Linux. Device type is inferred from Mobile/iPhone/iPad/Tablet markers, and a bot check looks for bot, crawl, spider, slurp, and bingpreview. Engine is derived from the browser family: Blink for Chrome/Edge/Opera, WebKit for Safari, Gecko for Firefox, Trident for old IE.

Everything runs locally — the UA you paste is never sent anywhere.

Where this helps

Analytics and logs

  • Server log analysis: Parse User-Agents from Apache or nginx access logs to understand browser and device distribution of traffic.
  • Traffic segmentation: Break down visitors by browser family, OS, or device for reporting and decision-making.
  • Anomaly detection: Spot unusual User-Agents in logs (outdated browsers, unknown bots) that may indicate problems.

Development and testing

  • Browser-specific bugs: Identify the exact browser and version from a user bug report User-Agent.
  • Responsive design: Verify your site is identifying mobile vs desktop users correctly based on UA classification.
  • Feature compatibility: Know the browser versions hitting your site to decide which features can be used without polyfills.

Bot and crawler management

  • Search engine crawler identification: Confirm Googlebot or Bingbot is actually visiting (UA + DNS lookup for verification).
  • Social media preview bots: Identify crawlers fetching for Open Graph or Twitter Card previews.
  • Abuse detection: Spot scraping bots with generic or unusual UAs for rate-limiting decisions.

Worked examples

Modern Chrome

Typical desktop Chrome User-Agent.

Input
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36
Output
browser: Chrome 118.0
OS: Windows 10
device: desktop
engine: Blink

iPhone Safari

Mobile iOS User-Agent.

Input
Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1
Output
browser: Safari 16.0
OS: iOS 16.0
device: mobile (iPhone)
engine: WebKit

Googlebot

Search engine crawler.

Input
Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)
Output
browser: Googlebot 2.1
bot: yes
type: search crawler
owner: Google

Firefox on macOS

Desktop Firefox.

Input
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:118.0) Gecko/20100101 Firefox/118.0
Output
browser: Firefox 118.0
OS: macOS 10.15 (Catalina)
device: desktop
engine: Gecko

Android Chrome

Mobile Chrome on Android.

Input
Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Mobile Safari/537.36
Output
browser: Chrome 118.0
OS: Android 13
device: mobile (Pixel 7)
engine: Blink

Common problems and solutions

User-Agent strings can be spoofed

Anyone can set any UA. Browsers have dev-tool overrides, bots impersonate real browsers, and extensions rewrite it. Never treat a parsed UA as trusted identity or a security control.

Windows 10 and 11 look identical

Both report 'Windows NT 10.0' — Microsoft never incremented the NT version for Windows 11. No UA parser can distinguish them from the string alone; that now requires client hints.

Modern browsers freeze the version

Chrome and others have reduced UA granularity for privacy, often reporting a capped or frozen version. The version shown may not be the exact build; User-Agent Client Hints are the modern replacement.

Every browser claims to be Mozilla and Safari

For legacy reasons a Chrome UA contains Mozilla, AppleWebKit, KHTML, Gecko, and Safari tokens. That's why naive parsing fails — this tool matches in a specific order to avoid it, but unusual strings can still trip it up.

It's a compact parser, not a full database

It recognizes the common browsers, OSes, and device classes. Rare browsers, specific device models, and many bots may show as Unknown or a generic type. Use a maintained library for exhaustive detection.

How it compares

Dedicated libraries like UAParser.js and server-side services maintain large, constantly updated device and browser databases, so they recognize far more edge cases (specific phone models, obscure browsers, bot fingerprints) than this tool's compact regex set. If you need production-grade detection or exhaustive device data, use one of those.

This tool is for the quick lookup: identifying the common browsers, OSes, and device classes without leaving the page or writing code. It gets the mainstream cases right and shows you the reasoning. For occasional debugging that's usually all you need; for analytics you depend on, reach for a maintained library — and lean on client hints where you can.

Frequently asked questions about the User Agent Parser

What is a User-Agent string?

It's a text header your browser sends with every request, describing the browser, its engine, and the operating system. Servers use it (cautiously) for content negotiation, analytics, and debugging. This tool decodes it into readable parts.

Why does my Chrome User-Agent mention Safari and Mozilla?

Historical compatibility. Early browsers copied each other's tokens so sites wouldn't lock them out, and the cruft stuck. Every Chromium browser still includes Mozilla, AppleWebKit, and Safari in its UA even though it's none of those.

Can I trust the User-Agent to identify a user?

No. It's trivially spoofed and should never be used for authentication or security decisions. It's fine for rough analytics and debugging, but treat it as a hint, not a fact.

Why can't it tell Windows 10 from Windows 11?

Because they send the same 'Windows NT 10.0' token. Microsoft didn't change the version for Windows 11, so the string is identical. Distinguishing them requires User-Agent Client Hints, not the classic UA string.

Is the User-Agent I paste sent anywhere?

No. Parsing runs entirely in your browser with local regular expressions. Nothing you paste, including your own browser's UA, leaves your device.

Useful references

Advertisement

Related tools

All Web Tools

Learn more

Explore more tools

200+ free tools that run in your browser.

Browse all tools →