User Agent Parser
Web ToolsParse 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.
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.
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36
browser: Chrome 118.0 OS: Windows 10 device: desktop engine: Blink
iPhone Safari
Mobile iOS User-Agent.
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
browser: Safari 16.0 OS: iOS 16.0 device: mobile (iPhone) engine: WebKit
Googlebot
Search engine crawler.
Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)
browser: Googlebot 2.1 bot: yes type: search crawler owner: Google
Firefox on macOS
Desktop Firefox.
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:118.0) Gecko/20100101 Firefox/118.0
browser: Firefox 118.0 OS: macOS 10.15 (Catalina) device: desktop engine: Gecko
Android Chrome
Mobile Chrome on Android.
Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Mobile Safari/537.36
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
- UAParser.js on npm — Popular JavaScript User-Agent parsing library used by many analytics tools.
- User-Agent Client Hints — Modern privacy-respecting replacement for User-Agent strings.
- WHATWG on User-Agent — Official spec context for User-Agent handling in browsers.
- Verifying Googlebot — Google’s official guidance on verifying Googlebot via DNS rather than UA alone.
- Deviceatlas User-Agent Database — Commercial UA database used for accurate device detection at scale.
Related tools
All Web ToolsAPI Request Builder
Build and test HTTP API requests with method, headers, body, authentication, and query parameters — inspect full response in your browser.
cURL to Code Converter
Convert cURL commands to equivalent code in Python (requests), JavaScript (fetch), PHP, Go, Ruby, Node, and other languages.
Hash Generator
Generate MD5, SHA-1, SHA-256, SHA-512 hashes for text and files
HTTP Headers Lookup
Complete reference for HTTP request and response headers with usage examples, RFC references, and common values.
HTTP Status Code Reference
Complete reference for every HTTP status code with meaning, usage guidelines, and examples for REST API design.
HTTP Status Code Lookup
Quick lookup tool for HTTP status codes — enter any status number and get the meaning, category, and usage guidelines instantly.
Learn more
Explore more tools
200+ free tools that run in your browser.
Browse all tools →