User Agent Parser
Paste any browser User-Agent string and break it down into browser, operating system, device type, and rendering engine.
What is a User-Agent String?
A User-Agent (UA) string is an HTTP request header that a web browser, crawler, or client app sends to web servers to identify its software application, version, operating system, and rendering engine. Developers and analytics platforms inspect this header to diagnose browser-specific bugs, evaluate audience demographics, and route traffic to compatible interfaces.
Browser Identification and Client-Hint Comparison
| Detection Strategy | Standard Mechanism | Spoofing Resistance | Privacy Profile | Modern Status |
|---|---|---|---|---|
| User-Agent Header (Classic) | HTTP Header / navigator.userAgent | Low (frequent compatibility masking) | Broad passive fingerprinting surface | Legacy baseline, frozen tokens |
| Client Hints (Sec-CH-UA) | Structured HTTP headers / navigator.userAgentData | High (granular, explicit permission) | High (low-entropy default, opt-in high) | Modern W3C standard (Chromium / WebKit WIP) |
| Feature Detection | window / DOM capability checks | Highest (tests actual API behavior) | Zero passive fingerprint exposure | Best practice for modern web engineering |
About the User Agent Parser
Quick Answer: The User Agent Parser instantly decodes any raw HTTP user-agent header or your current browser string to identify browser name, exact version, operating system, device family, and rendering engine. It runs client-side with zero telemetry or server requests.
The box loads with your own browser real User-Agent string so there is something to look at right away, and "Parse My Browser" refreshes it if you have typed over it. Detection runs through a set of ordered regular expressions rather than a lookup table: Edge and Opera are checked before Chrome since their Chromium-based strings also contain "Chrome/", and Safari is only matched when "Chrome/" is absent, since real Chrome user agents contain "Safari/" too. Any field the patterns cannot confidently identify shows as "Unknown" instead of guessing or breaking.
Why user agent strings are such a historical tangle in the first place
The ordered-check approach exists because of decades of browser vendors deliberately impersonating each other for compatibility reasons. When Chrome launched, websites were already sniffing for "Safari" and "Mozilla" in the user agent to decide whether to serve modern layouts, so Chrome user agent string still opens with "Mozilla/5.0" and includes "Safari/" even though it is neither, it inherited those tokens purely so older website compatibility checks would not break. That is exactly why this tool detection has to check the most specific, exclusive marker first (a real Edge string always contains "Edg/") before falling back to broader, inherited markers, a naive single keyword search for "Safari" would misidentify the overwhelming majority of real-world Chrome, Edge, and Opera users as Safari.
Anatomy of a Modern User-Agent String
A contemporary desktop browser User-Agent string looks like a confusing mosaic of conflicting brand tokens. For example, consider this standard Chrome string on Windows:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36
Breaking down each architectural component reveals the evolutionary heritage of web standards:
- Mozilla/5.0: Historical compatibility token claiming ancestry from Netscape Navigator. Almost every consumer browser since the early 2000s begins with this token to bypass legacy web server routing blocks.
- (Windows NT 10.0; Win64; x64): The platform architecture token enclosed in parentheses. It specifies the host operating system (Windows NT kernel 10.0) and processor architecture (64-bit Intel/AMD).
- AppleWebKit/537.36: The rendering framework token. Chrome originated from WebKit (which itself forked from KDE's KHTML engine). Even though Chrome now uses Google's Blink engine, it continues to advertise AppleWebKit build 537.36 for backward compatibility.
- (KHTML, like Gecko): Sub-tokens indicating behavioral compatibility with KDE KHTML and Mozilla Gecko rendering rules.
- Chrome/126.0.0.0: The actual product identifier and major release version number. Under modern Chrome User-Agent reduction policies, the minor, build, and patch numbers are frozen at
0.0.0. - Safari/537.36: A concluding token added when Chrome originally launched to ensure web servers that supported Safari's WebKit engine would also serve modern CSS and JavaScript to Chrome users.
A real, unfixable limitation: Windows 10 and 11 report identically
Microsoft never incremented the underlying NT kernel version number when Windows 11 launched, it is still internally NT 10.0, exactly the same value Windows 10 reports. That means the user agent string itself contains no information that could distinguish the two, which is why this tool Windows detection deliberately maps NT 10.0 to the combined label "Windows 10/11" rather than falsely claiming certainty it cannot actually have. This is not a gap in this tool parsing logic, it is a genuine limitation of the User-Agent format itself, no parser, however sophisticated, can recover information the string never contained.
Another real limitation: modern iPads can report themselves as Macs
Since iPadOS 13, Safari on iPad defaults to a "desktop" user agent that specifically identifies as "Macintosh" rather than "iPad," a deliberate choice by Apple so websites serve the full desktop layout instead of a scaled-down mobile version by default. That means a genuine, current iPad can be entirely indistinguishable from an actual Mac purely by reading its user agent string. This is true of every user-agent-based detection method, not something specific to this tool, and it is one of several reasons device and OS detection based on this string alone has become progressively less reliable over the past several years.
How the rendering engine gets inferred, and why it checks the browser first
Rather than independently re-scanning the raw user agent string for engine-specific keywords, this tool first checks which browser it already identified and infers the engine from that (Firefox implies Gecko, Safari implies WebKit, any Chromium-based browser implies Blink), only falling back to directly searching for "AppleWebKit" or "Gecko" substrings if the browser itself could not be determined. That ordering matters for the same historical-spoofing reason covered above, nearly every modern browser user agent string contains "AppleWebKit" somewhere in it as an inherited legacy compatibility token, regardless of what engine it actually runs, so a direct keyword search alone would misidentify Blink and Gecko browsers as WebKit far too often.
The Privacy Paradigm Shift: User-Agent Reduction and String Freezing
Over the past two decades, advertisers and tracking networks exploited the high granularity of User-Agent strings (exact build revisions, OS build numbers, CPU architecture, screen dimensions) to calculate unique cryptographic fingerprints for cross-site user tracking without consent. In response, the W3C, Chromium team, and Apple WebKit engineers enacted User-Agent Reduction:
- Minor Version Freezing: Chrome, Edge, and other Chromium browsers freeze minor version components (e.g.
126.0.0.0instead of126.0.6478.127). - Unified Platform Strings: On desktop operating systems, platform details are standardized to reduce unique entropy bits. Mobile device models in Android strings are increasingly mapped to generic virtual models.
- Safari Reduction: Safari similarly reports uniform macOS versions (such as
Mac OS X 10_15_7) across macOS Monterey, Ventura, Sonoma, and Sequoia to shield users from passive tracking.
The Modern Replacement: User-Agent Client Hints (UA-CH)
To replace brittle string parsing with structured, privacy-preserving signals, modern browsers introduced User-Agent Client Hints. Instead of broadcasting exhaustive system details on every single HTTP request, browsers transmit low-entropy hints by default, such as:
Sec-CH-UA: "Chromium";v="126", "Google Chrome";v="126", "Not/A)Brand";v="8"Sec-CH-UA-Mobile: ?0Sec-CH-UA-Platform: "Windows"
If a web server genuinely requires high-entropy details (such as whether the device runs Windows 10 or Windows 11, or the exact device model on Android), it must explicitly send an Accept-CH: Sec-CH-UA-Platform-Version, Sec-CH-UA-Model response header. The browser then decides whether to disclose those specific fields on subsequent requests based on user privacy permissions.
Backend Parser Implementations: Regex Heuristics vs Device Databases
Depending on application requirements, production systems implement user-agent analysis using two primary architectural strategies:
- Lightweight Regular Expression Heuristics: Fast, in-memory regex chains (identical to the engine powering this tool) analyze dominant browser and operating system families in sub-millisecond execution times. This approach incurs zero external latency and zero database lookups, making it ideal for edge computing, CDN workers (Cloudflare Workers, Fastly VCL), and real-time routing.
- Comprehensive Device Detection Repositories: Enterprise analytics and mobile ad networks rely on commercial lookup engines (such as WURFL, DeviceAtlas, or 51Degrees) backed by tens of thousands of regex signatures. These repositories track obscure smart TV browsers, vehicle infotainment head units, gaming consoles, and bot scrapers.
Server-Side Implementation Examples
Developers who need to extract browser metadata in backend web services can reference these standard implementations:
| Environment | Recommended Library | Typical Code Pattern |
|---|---|---|
| Node.js / Express | ua-parser-js |
const UAParser = require('ua-parser-js'); const res = new UAParser(req.headers['user-agent']).getResult(); |
| Python / Django / FastAPI | user-agents |
from user_agents import parse; ua = parse(request.headers.get('User-Agent')); is_mobile = ua.is_mobile |
| Go (Golang) | github.com/mileusna/useragent |
ua := useragent.Parse(r.UserAgent()); fmt.Println(ua.Name, ua.Version, ua.OS) |
| PHP | whichbrowser/parser |
$parser = new WhichBrowser\Parser($_SERVER['HTTP_USER_AGENT']); echo $parser->browser->toString(); |
Zero-Trust Local Execution and Privacy Guarantee
Because User-Agent headers can reveal device models, hardware architecture, and internal enterprise proxy routing information, your privacy is strictly protected. This utility executes all regular expressions, version extraction routines, and device categorizations entirely inside your local browser memory. No headers, strings, IP addresses, or telemetry data are ever transmitted to external servers or logged in central repositories.
Frequently Asked Questions
Why does the detection logic check for Edge and Opera before checking for Chrome?
Both Edge and Opera are Chromium-based and include Chrome/ in their user agent strings as an inherited compatibility token. Checking for their more specific, exclusive markers (Edg/ and OPR/) first prevents them from being misidentified as Chrome.
Can this tool tell Windows 10 apart from Windows 11?
No, and no user agent parser can, Microsoft never changed the underlying NT kernel version number for Windows 11, so both report identically as Windows NT 10.0. This tool reflects that honestly with a combined Windows 10/11 label rather than falsely claiming certainty it cannot have.
Why might a real iPad get detected as a Mac?
Since iPadOS 13, Safari on iPad defaults to identifying itself as Macintosh in the user agent so websites serve the full desktop layout. This makes a genuine iPad indistinguishable from an actual Mac by user agent string alone, a limitation of the format itself, not this specific tool.
Why does the tool infer the rendering engine from the browser name instead of scanning the string directly?
Nearly every modern browser user agent string contains AppleWebKit as an inherited legacy token regardless of its actual engine, so a direct keyword search alone would misidentify Blink and Gecko browsers as WebKit too often. Inferring from the already-detected browser name first avoids that false positive.
Is the User-Agent string still a reliable way to detect browsers and devices?
It has become progressively less reliable due to decades of browsers deliberately impersonating each other for compatibility, which is part of why the newer User-Agent Client Hints API exists as a more structured, explicit alternative. The classic string is still universal for now, which is why parsing it remains useful.
What happens if the parser cannot confidently identify a field?
It shows Unknown for that field rather than guessing. This is a deliberate design choice, since a confident-looking but wrong guess would be more misleading than honestly reporting that the pattern did not match anything recognized.
What is User-Agent Client Hints (UA-CH) and how does it replace legacy strings?
User-Agent Client Hints (Sec-CH-UA) provides structured HTTP request headers where browsers provide high-entropy platform details (such as exact architecture and OS version) only upon explicit server request, reducing passive digital fingerprinting.
Why do almost all browser user agents start with Mozilla/5.0?
During the early web browser wars, servers checked for Netscape Navigator (code-named Mozilla) before serving advanced frames and script features. Competing browsers, starting with Internet Explorer, added Mozilla/ to avoid being served degraded legacy pages, creating a permanent tradition.
What is User-Agent reduction and string freezing in modern Chrome and Safari?
Browser vendors freeze minor OS versions and hardware tokens in the User-Agent header to reduce cross-site user fingerprinting. Chrome, for example, reports fixed OS versions and unified device values across desktop platforms.
Can malicious bots or crawlers spoof their User-Agent string?
Yes. Any HTTP client, cURL command, or automated scraper can arbitrarily configure its User-Agent header. Critical security decisions should never rely solely on User-Agent detection without IP reputation, cryptographic challenge, or behavioral analysis.