User Agent Parser

Parse and analyse any User Agent string. Identify browser, OS, device type, and rendering engine instantly.

Free to use. Runs in your browser.

Paste a user-agent string to see the browser, browser version, operating system, device type, and engine. Useful for debugging device-specific issues.

Treat parsed values as hints for debugging and analytics, not as proof of identity or security state.

User Agent String

Browser

Google Chrome 146.0.0.0

Operating System

macOS 10.15.7

Device Type

Desktop

Rendering Engine

WebKit/Blink

Spoofing

Browsers, bots, and test tools can change user-agent strings, so never use them for access control.

Logs

In access logs, the user agent is often the final quoted field after the path, status, and referrer.

Client Hints

Some browsers provide structured UA Client Hints with less detail than the legacy string.

Parsing limit

The parser identifies common browser families and device types. Unknown bots, custom apps, and spoofed strings may need manual review.

For feature support, test the feature directly in code rather than relying on a browser name.

What Is a User Agent String?

Every time your browser requests a web page, it sends a User-Agent header that identifies itself. This string tells the server which browser you're using, which version, what operating system you're on, and sometimes which device. It's basically your browser's name tag.

The problem? User agent strings are notoriously messy. They've accumulated decades of compatibility hacks. Chrome's user agent contains "Safari" and "Mozilla" for historical reasons, every new browser pretends to be every older browser to avoid being blocked by servers that check for specific strings.

This parser untangles that mess. Paste a user agent string and instantly see the browser, version, operating system, device type, and rendering engine, without manually decoding the compatibility tokens.

Anatomy of a User Agent String

Component	Example	What It Means
Mozilla/5.0	Mozilla/5.0	Compatibility token, almost every browser sends this regardless
Platform	(Windows NT 10.0; Win64; x64)	OS and architecture, Windows 10, 64-bit
Engine	AppleWebKit/537.36	Rendering engine, Blink-based browsers use WebKit token
Browser	Chrome/120.0.6099.130	Actual browser name and version
Compatibility	Safari/537.36	Legacy token, Chrome includes Safari for compatibility

What this means for you: Don't try to parse user agents with simple string matching. The tokens are misleading by design. Use a proper parser (like this tool) or a server-side library.

Common User Agents by Device Type

Device	Key Identifier	Notes
Desktop Chrome	Chrome/xxx, no "Mobile"	Most common browser globally (~65% market share)
Mobile Chrome (Android)	Chrome/xxx Mobile, Linux; Android	Includes Android version and device model
Safari (Mac)	Version/xx Safari/xxx, Macintosh	Only browser without Chrome token
Safari (iPhone)	iPhone; CPU iPhone OS, Mobile Safari	All iOS browsers use WebKit engine underneath
Firefox	Gecko/xxx Firefox/xxx	Uses Gecko engine, only major non-WebKit/Blink browser
Googlebot	Googlebot/2.1 or Googlebot-Mobile	Google's web crawler, renders JavaScript
Bingbot	bingbot/2.0	Microsoft's search crawler

Why User Agents Matter

Analytics and Reporting

Your analytics platform parses user agents to show browser and device breakdowns. If your site gets 40% mobile traffic but your design only looks good on desktop, the user agent data tells you that.

Bot Detection

Legitimate crawlers identify themselves via user agent strings. Googlebot, Bingbot, and social media scrapers all have distinctive signatures. Parsing these helps you serve appropriate content.

Bug Reproduction

When a user reports a bug, their user agent tells you exactly which browser, version, and OS to test on. This cuts debugging time dramatically compared to "it doesn't work on my phone."

Content Negotiation

Some sites serve WebP images to Chrome and JPEG to older browsers. Others serve lighter pages to mobile devices. User agent detection (combined with feature detection) enables this.

Why User Agent Strings Are So Messy

Current browser user agent strings contain "Mozilla/5.0", even Chrome, even Safari, even Edge. This is a legacy of the 1990s browser wars. When Netscape Navigator was dominant, websites checked for "Mozilla" to serve feature-rich pages. Every browser since has included "Mozilla" in its UA string to avoid being served a degraded experience.

The result is absurd strings like Chrome's: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36. It claims to be Mozilla, uses WebKit, is "like Gecko", and mentions Safari, despite being Chrome on Windows. This is why parsing UA strings requires specialised tools rather than simple string matching.

What You Can and Cannot Trust

Signal	Useful For	Limit
Browser family	Reproducing layout bugs	Can be spoofed or hidden behind compatibility tokens
Operating system	Checking platform-specific issues	May be vague or outdated
Device type	Analytics and rough debugging	Large phones, tablets, and desktop mode can blur categories
Bot name	Grouping crawler traffic	Malicious bots can impersonate legitimate crawlers
Browser version	Feature-support checks	Feature detection is safer for runtime decisions

Use user agent parsing to narrow a question, then confirm with logs, feature checks, device testing, or bot verification when the decision matters.

Client Hints and Reduced User Agent Data

UA Client Hints expose structured values such as brands, platform, mobile status, and sometimes architecture. They were introduced because legacy user agent strings reveal a lot of passive fingerprinting data while still being hard to parse.

Legacy User-Agent

Always sent by browsers, widely logged by servers, and full of compatibility tokens. Good for historic logs and broad grouping.

UA Client Hints

More structured, but some high-detail values require opt-in headers and browser support. Good for new applications that need cleaner detection.

Feature detection

For code paths, test the feature directly. Checking whether WebP, CSS Grid, or an API exists is usually safer than guessing from a browser name.

Server logs

Logs often contain only the legacy string. Parsing still helps for incident review, support tickets, analytics, and crawler traffic.

Bot and Crawler Checks

A user agent that says Googlebot is not proof that the request came from Google. Treat bot names as claims until you verify the source when access, crawl budget, or abuse controls are involved.

Step	What to Check	Why It Matters
1	User agent name	Groups likely crawler traffic for initial review
2	Reverse DNS	Confirms whether the IP maps to the claimed crawler domain
3	Forward DNS	Confirms that hostname resolves back to the same IP
4	Request behaviour	Checks rate, paths, and robots.txt respect

Reading User Agents from Logs

Apache and Nginx common logs

The user agent is often the final quoted value. Copy only the string inside those final quotes, not the status code, referrer, or IP address before it.

JSON logs

Look for fields named user_agent, user-agent, http_user_agent, request.headers.userAgent, or similar. Decode escaped quotes before parsing.

Support tickets

Pair the user agent with viewport size, device model, time of report, and the exact URL. The string alone rarely explains a bug fully.

Related Tools

HTTP Status Code Lookup

Look up HTTP response codes from your server logs.

URL Encoder/Decoder

Decode URL-encoded user agent strings from logs.

JSON Formatter

Format parsed user agent data as clean JSON.

Regex Tester

Build regex patterns to extract user agent components.

Screen Size Checker

Check viewport dimensions alongside device identification.

Robots.txt Generator

Control which user agents can crawl your site.

How to use this tool

Your current browser's user agent is auto-detected on page load

Paste any custom user agent string to analyse it

Click Parse to see the browser, OS, device type, and rendering engine

Common uses

Identifying browser and OS from server log entries
Debugging device-specific rendering issues from user bug reports
Detecting bot traffic in website analytics
Understanding which browsers your users actually use

Share this tool

Frequently Asked Questions

What is a User Agent string?

It's a header sent by your browser to websites identifying your browser, OS, and device. Servers use it to serve appropriate content and track analytics.

Can I parse a custom User Agent?

Yes. Paste any User Agent string into the input to analyse it. Useful for checking strings from server logs, analytics reports, or bug reports.

Is this accurate?

It uses pattern matching for common browsers and OS families. Edge cases with spoofed or unusual user agents may not parse perfectly, but it handles all major browsers reliably.

Why does Chrome's user agent contain 'Safari' and 'Mozilla'?

Historical compatibility. Each new browser added existing browser tokens to avoid being blocked by servers checking for specific strings. Chrome inherited Safari's token, which inherited Mozilla's. It's messy but that's the web.

What's the difference between a rendering engine and a browser?

The rendering engine draws web pages, Blink powers Chrome/Edge, Gecko powers Firefox, WebKit powers Safari. Multiple browsers can share the same engine. The browser is the user-facing application.

Can user agent strings be spoofed?

Yes, easily. Browser extensions and developer tools can change the user agent string. This means user agent detection should never be used for security, only for analytics and content optimisation.

What is a bot user agent?

Web crawlers like Googlebot, Bingbot, and social media scrapers identify themselves with distinctive user agent strings. Legitimate bots include their name and a URL with documentation.

Why is my current user agent detected automatically?

The tool reads your browser's navigator.userAgent property, which is available to any JavaScript running in your browser. This is the same string your browser sends to every website you visit.

What are Client Hints replacing user agents?

Client Hints (UA-CH) is a newer API that provides structured, lower-entropy device information. Chrome is gradually reducing user agent detail and moving to Client Hints for privacy reasons.

How do I find a user agent in server logs?

In Apache/Nginx logs, the user agent is typically the last quoted string in each log line. In JSON-formatted logs, look for the 'user-agent' or 'http_user_agent' field.

Is my data sent anywhere?

No. All parsing happens in your browser using JavaScript pattern matching. Nothing is uploaded or stored.

What mobile devices can be detected?

The parser identifies iOS (iPhone/iPad), Android devices, and tablets based on keywords in the user agent string. Specific device models are sometimes included in Android user agents.

Results are for general informational purposes only and should be checked before use. They are not professional advice. See our Disclaimer and Terms of Service.