Home · Tools · User Agent Parser

User Agent Parser

Parse User-Agent strings into structured browser, OS and device information.

Sample signatures

Raw User-Agent

Quick actions: use the sample signatures, compare two UAs, or auto-detect your current browser.

Live detection

Quick insights

Introduction

A user agent is the identifier a browser or crawler sends to every HTTP request. Developers use a user agent parser online to decode browser, operating system, device and crawler metadata from that string. This page is built for engineers who need accurate browser detection, device detection, crawler analysis and raw user agent lookup in the browser.

What is a user agent?

A user agent string is a compact text header that represents the client software, platform and rendering engine. It exists for compatibility: servers use it to decide whether to serve mobile layouts, browser-specific scripts or crawler-safe content.

Typical formats include:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Mozilla/5.0 (iPhone; CPU iPhone OS 17_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Mobile/15E148 Safari/604.1

Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)

The string contains tokens for browser brand, engine, operating system, device model and sometimes bot identity. Modern browsers still include legacy compatibility markers like Mozilla/5.0 and Safari even when the real engine is Chromium.

How user agent parsing works

A good user agent string parser uses deterministic rules to extract browser name, version, OS, device type and engine. Parsing user agent data is usually token-based, not AI-based, because consistency and speed matter in the browser.

Browser detection

The parser checks common markers such as Chrome/, Firefox/, Edg/ and Safari/. It also handles overlapping signatures, such as Chrome shells and Chromium-based edge cases.

Operating system extraction

OS detection looks for tokens like Windows NT, Mac OS X, Android and iPhone OS. That allows this tool to identify whether a parsed user agent came from Windows, macOS, Linux, Android or iOS.

Rendering engine detection

Rendering engine detection separates Blink, WebKit, Gecko and Trident. Even when the browser is Chrome or Safari, the engine token reveals how HTML and CSS are actually rendered.

Device identification

Device detection distinguishes desktop, mobile and tablet clients. For Android and iOS user agents, the parser also extracts vendor and model hints to support mobile user agent parser workflows.

Parsing user agent strings is not foolproof. Spoofed user agents, inconsistent vendor formats and crawler impersonation are real challenges for any user agent lookup solution.

Common use cases

Analytics — enrich logs with browser and OS labels.
Responsive design — choose breakpoints based on mobile vs desktop signatures.
Browser compatibility — detect rendering engines and platform capabilities.
Bot detection — identify crawler traffic before recording or routing requests.
SEO crawler analysis — verify Googlebot, Bingbot and social media scrapers.
Security investigations — flag headless or script driven user agents.
Debugging API requests — inspect the raw user agent submitted by clients and test fallback behavior.
Log analysis — categorize traffic from server access logs with a lightweight parser.

Bot & crawler user agents

Crawlers and bots identify themselves with dedicated bot user agent strings. Common examples include Googlebot, Bingbot, ChatGPT crawler, Facebook crawler and Twitterbot.

Developers inspect crawler traffic to ensure SEO crawlers receive the same content as browsers, to monitor crawl coverage, and to separate bot traffic from normal sessions.

Mozilla/5.0 (compatible; Bingbot/2.0; +http://www.bing.com/bingbot.htm)

This tool classifies those strings and reveals whether a parsed user agent is likely a bot or a browser-like client.

Mobile vs desktop user agents

Mobile user agents contain extra device metadata and often include Mobile or vendor identifiers. Desktop agents are usually narrower and include CPU architecture hints.

Android user agents commonly contain Android, a device model, and Mobile Safari. iPhone user agents include iPhone OS and a Safari-compatible engine token.

Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Mobile Safari/537.36

Tablet detection is handled by examining iPad or the absence of mobile-only markers in Android strings.

Privacy & security

User agent parsing should be privacy-friendly. This tool runs entirely in the browser, with no backend processing and no user agent strings uploaded to any server.

User agent spoofing is common, and privacy-focused browsers may hide or normalize identifying details. For security use cases, treat UA signals as advisory rather than authoritative.

Spoofed user agents can mimic browsers or crawlers.
Fingerprinting is more robust when combined with client hints and runtime features.
Outdated browsers may lack security patches and modern engine support.

Technical reference

Browser rendering engines

Rendering engine detection maps user agent tokens to Blink, Gecko, WebKit and Trident. This is useful when a browser-brand check alone is insufficient for compatibility analysis.

Chromium vs Gecko vs WebKit

Blink — used by Chrome, Edge and Opera.
WebKit — used by Safari and iOS webviews.
Gecko — used by Firefox.
Trident — legacy Internet Explorer.

Modern UA format changes

Recent browsers preserve compatibility by continuing to include legacy tokens like Mozilla/5.0 and Safari. The parser accounts for these historical quirks so browser detection remains reliable.

User-Agent Client Hints

User-Agent Client Hints are a newer browser feature that separates client metadata into structured headers. This parser remains focused on traditional user agent string parsing, while still accounting for modern client behavior.

Limitations of user agent parsing

User agent parsing is best for surface-level browser and device classification. It cannot fully verify user identity, and it should be combined with runtime feature detection or server-side Client Hints for robust compatibility checks.

Related tools

FAQ

What is a user agent parser?

A user agent parser extracts structured metadata from a browser's raw user agent string. It identifies browser name, version, OS, device type and crawler signals.

How do I decode a user agent string?

Decode a user agent string by matching common tokens for browser, engine, operating system and device model. This page parses those tokens in the browser without sending data to a server.

Can user agents be spoofed?

Yes. User agents can be modified by browsers, automation tools and crawlers. Treat user agent parsing as a heuristic, not a security boundary.

How do bots identify themselves?

Bots usually include a known crawler string like Googlebot or Twitterbot. This parser checks for those markers and surfaces bot category and search engine association.

How do I detect mobile devices?

Mobile detection uses tokens such as Mobile, Android, iPhone and iPad. Tablets and phones are differentiated from desktop clients based on those markers.

Why does Chrome user agent contain Safari?

Chrome uses the WebKit-compatible token Safari for compatibility. The parser recognizes Chrome-specific tokens to avoid false positives.

Is user agent parsing accurate?

It is accurate for standard browser and crawler patterns, but less reliable for spoofed or privacy-hardened strings. This tool reports confidence levels and parser assumptions.

What is a browser rendering engine?

A rendering engine is the core layout and JavaScript engine used by a browser, such as Blink, Gecko, WebKit or Trident. User agent parser logic uses engine tokens to improve compatibility diagnosis.

What is the difference between browser and operating system detection?

Browser detection identifies client software like Chrome or Safari. OS detection maps the platform to Windows, macOS, Android, iOS or Linux. Both are needed for accurate user agent analytics.