100% client-side, nothing ever leaves your browser
User Agent Parser & Decoder
Paste any user-agent string — or use the one this page auto-detected from your browser — and decode the browser, version, rendering engine, operating system, device type and CPU architecture. Instant, private, 100% client-side.
Parsed result
User-Agent Client Hints (your browser, low-entropy)
Modern Chromium browsers reduce the UA string and expose details here instead, via navigator.userAgentData. Only available over HTTPS in supporting browsers.
Results are inferred from the text of the user-agent string, which browsers self-report and which can be modified or spoofed. Treat this as a best-effort interpretation rather than a guaranteed fact.
How user-agent parsing works
UAParser.js matches known patterns in the string against a large database of browser, OS, and device signatures.
Paste a user agent
Paste any user-agent string, pick a sample, or use your own browser's string.
Automatic parsing
Browser, OS, device type, engine, and a heuristic bot check are all computed immediately.
Copy the result
Copy the full parsed result as JSON for use in a bug report or log analysis.
Privacy note: parsing happens entirely in your browser using a JavaScript library loaded from a CDN. The string you enter is never sent to a server.
Common uses
Debugging browser-specific bugs
Decode a user-agent string from a bug report or support ticket to identify the exact browser and OS involved.
Reading server access logs
Understand which browsers and devices are hitting your server by parsing raw user-agent strings from logs.
Spotting crawler traffic
Get a quick heuristic read on whether a request came from a known bot or crawler.
Testing responsive design assumptions
Check how a specific mobile or tablet user agent would be classified by device-detection logic.
What is a user agent?
A user agent is the software acting on your behalf when it makes an HTTP request — normally a web browser, but also crawlers, command-line tools and libraries. Each request carries a User-Agent header: a single free-form string the client sends to identify itself. The server, or a script like this one, can read that string to guess the browser, engine, operating system and device.
Anatomy of a user-agent string
A typical desktop Chrome string, broken into the tokens a parser looks at:
| Token | Meaning |
|---|---|
| Mozilla/5.0 | Legacy compatibility token. Present in almost every browser and carries no real information. |
| (Windows NT 10.0; Win64; x64) | Platform block — operating system and CPU architecture. |
| AppleWebKit/537.36 (KHTML, like Gecko) | Engine heritage token — Blink forked from WebKit, so it still claims WebKit for compatibility. |
| Chrome/126.0.0.0 | The actual browser and its (now reduced) version number. |
| Safari/537.36 | Another compatibility token kept so old Safari-sniffing code still works. |
This is why hand-rolled regex detection is fragile: the string is full of deliberately misleading tokens for backward compatibility. Use a maintained parser.
User-agent examples
| Client | User-agent string |
|---|---|
| Chrome / Windows | Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 |
| Safari / iPhone | Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1 |
| Firefox / macOS | Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:126.0) Gecko/20100101 Firefox/126.0 |
| Chrome / Android | Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Mobile Safari/537.36 |
| Googlebot | Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) |
Parsing user agents in JavaScript
This tool uses UAParser.js. The same call in your own code:
import { UAParser } from 'ua-parser-js';
const ua = navigator.userAgent; // or a string from a server log
const { browser, engine, os, device, cpu } = UAParser(ua);
console.log(browser.name, browser.version); // "Chrome" "126.0.0.0"
console.log(os.name, os.version); // "Windows" "10"
console.log(device.type || 'desktop'); // "mobile" | "tablet" | undefined
// Prefer precise data from Client Hints where available (Chromium, HTTPS):
if (navigator.userAgentData) {
const high = await navigator.userAgentData
.getHighEntropyValues(['platformVersion', 'model']);
console.log(high.platformVersion, high.model);
}Browser detection limitations
- The string is self-reported. Any client can send anything — extensions, privacy tools and scripts routinely change it.
- UA reduction. Chrome, Edge and other Chromium browsers now freeze most of the string and round the OS version and device model down, so "Windows NT 10.0" no longer means Windows 10 specifically.
- Client Hints replace it. Detailed values are moving to navigator.userAgentData and the Sec-CH-UA-* request headers, which are only sent over HTTPS and only by supporting browsers.
- Device type is inferred. "Desktop" usually just means "no mobile or tablet token was found", not a positive identification.
- Prefer feature detection. For deciding what code to run, test for the capability you need rather than guessing from the browser name.
Frequently asked questions
How accurate is user-agent parsing?
User-agent strings are self-reported by the browser and can be spoofed or blank, so parsing them is a best-effort interpretation rather than a guarantee. Results are generally reliable for real, unmodified browser strings.
How is device type determined?
The parser looks for known mobile, tablet, TV, and other device signatures in the string. When no such signature is found, the device is inferred to be a desktop, since that's the most common case rather than a directly confirmed fact.
Is bot detection reliable?
Bot detection here is a heuristic check against known crawler and bot name patterns, such as Googlebot or curl. It can miss bots that disguise themselves with a normal browser string and may occasionally flag unusual legitimate clients, so treat the result as a signal, not a certainty.
What is a rendering engine?
The rendering engine, such as Blink, Gecko, or WebKit, is the underlying software that lays out and displays web pages. Multiple browsers can share the same engine, for example Chrome and Edge both use Blink.
Is my user-agent string sent anywhere?
No. Parsing happens entirely in your browser using a JavaScript library loaded from a CDN. The string you enter is never sent to a server.
Can I check my own browser's user agent?
Yes. The page auto-fills your current browser's actual user-agent string on load, and the "Use my browser" button re-fills it at any time.
How do I parse a user-agent string in JavaScript?
Use a maintained library such as UAParser.js: const parser = new UAParser(uaString); const result = parser.getResult(); which returns browser, engine, os, device and cpu objects. See the code example above. Writing your own regex is fragile because user-agent strings deliberately contain misleading tokens like the word "Mozilla" in every browser.
Why is user-agent detection considered unreliable now?
Chrome and other Chromium browsers have frozen and reduced the user-agent string, so it no longer reports a precise OS version or device model. Detailed values now come from the User-Agent Client Hints API (navigator.userAgentData) instead, and only over HTTPS. Feature detection is preferred over user-agent sniffing wherever possible.
More tools
Additional utilities from the same toolkit.