Ttooleras
🔍

User Agent Parser

Web Tools

Parse 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.

This tool is coming soon. Check back later!

Advertisement

The User Agent Parser breaks down any User-Agent string into its component parts: browser name and version, operating system, device type, rendering engine, and bot/crawler status. User-Agent strings are the cryptic text that every browser sends with every request (something like \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36\"), and parsing them is a constant task for web analytics, server logs, bot detection, responsive serving, and compatibility debugging.

Paste any User-Agent string and the parser identifies the browser family, exact version, operating system with version, device type (desktop, mobile, tablet, bot), and rendering engine. Bot detection flags known crawlers (Googlebot, Bingbot, social-media preview bots). Batch mode processes many User-Agents at once, useful for log analysis. All parsing runs in your browser with no network requests, so server logs (which sometimes contain PII in User-Agent strings) stay private. The parser is based on the same open-source libraries (UAParser.js, ua-parser-js) used by major analytics tools, so results match what Google Analytics, Mixpanel, and others would report.

User Agent Parser — key features

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.

How to use the User Agent Parser

  1. 1

    Paste User-Agent string

    Drop a User-Agent string into the input field. Enter your own by clicking the "use my UA" button.

  2. 2

    Read the breakdown

    Parsed components appear immediately: browser, version, OS, device type, engine, bot status.

  3. 3

    Batch multiple

    Paste many User-Agents (one per line) for batch parsing with summary statistics.

  4. 4

    Filter by browser

    In batch mode, filter by browser family, OS, or device to focus on specific segments.

  5. 5

    Export results

    Copy the parsed breakdown as JSON, CSV, or a summary table.

Common use cases for the User Agent Parser

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.

User Agent Parser — examples

Modern Chrome

Typical desktop Chrome User-Agent.

Input
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36
Output
browser: Chrome 118.0
OS: Windows 10
device: desktop
engine: Blink

iPhone Safari

Mobile iOS User-Agent.

Input
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
Output
browser: Safari 16.0
OS: iOS 16.0
device: mobile (iPhone)
engine: WebKit

Googlebot

Search engine crawler.

Input
Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)
Output
browser: Googlebot 2.1
bot: yes
type: search crawler
owner: Google

Firefox on macOS

Desktop Firefox.

Input
Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:118.0) Gecko/20100101 Firefox/118.0
Output
browser: Firefox 118.0
OS: macOS 10.15 (Catalina)
device: desktop
engine: Gecko

Android Chrome

Mobile Chrome on Android.

Input
Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Mobile Safari/537.36
Output
browser: Chrome 118.0
OS: Android 13
device: mobile (Pixel 7)
engine: Blink

Technical details

User-Agent strings have a chaotic history. They were designed with good intent (let servers know what client they are dealing with) but evolved into a mess because every new browser added tokens to claim compatibility with older ones. That is why Chrome\u2019s UA contains \"Mozilla\", \"Safari\", \"AppleWebKit\", and \"KHTML, like Gecko\" — all claims of compatibility with various older browsers.

Parsing strategy: regex patterns match known browser and OS identifiers. Order matters because patterns overlap (Chrome UA contains Safari, so you must check Chrome first). Modern parsers use a precompiled pattern list with priority ordering.

Chrome: matches \"Chrome/[version]\" but not \"Chromium/\" (a distinct browser) or \"CriOS/\" (Chrome on iOS, which Apple forces to use Safari engine).

Edge: modern Edge is Chromium-based, matches \"Edg/[version]\". Legacy Edge matched \"Edge/[version]\" — both patterns needed.

Firefox: \"Firefox/[version]\" is straightforward.

Safari: matches \"Version/[version] Safari/\" (the order matters because the \"Safari/\" token appears in many non-Safari UAs claiming compatibility).

Internet Explorer: matches \"MSIE [version]\" (IE 10 and earlier) or \"Trident/[version]; rv:[version]\" (IE 11). Modern, almost never seen.

Mobile detection: \"Mobile\", \"iPhone\", \"iPad\", \"Android\" tokens. iPad is tricky because recent iPadOS versions default to the desktop UA string.

OS detection: \"Windows NT [version]\", \"Mac OS X [version]\", \"Android [version]\", \"iPhone OS [version]\" (note: iPhone OS versions use underscores instead of dots). Linux variants are harder because UAs rarely specify distribution.

Bot detection: look for known bot User-Agents (Googlebot, Bingbot, Slurp, DuckDuckBot, YandexBot, Applebot, FacebookExternalHit, Twitterbot, LinkedInBot). Also generic indicators like \"bot\", \"crawl\", \"spider\" tokens.

Reduced User-Agent: Chrome and Edge are freezing User-Agent strings to a static value per privacy initiative. Modern clients should use the User-Agent Client Hints API (Sec-CH-UA-*) for reliable info. The parser still works on frozen UAs but with less version detail.

Accuracy caveats: User-Agent strings can be spoofed easily. Never rely on UA for security decisions. For analytics and feature detection, UA gives approximate device/browser info; combine with actual feature detection for reliability.

Common problems and solutions

⚠User-Agents are easily spoofed

Any client can send any User-Agent string. Never use UA for security decisions — it’s trivial to bypass. Use it for analytics and compatibility, not access control.

⚠iPad uses desktop UA

Recent iPadOS defaults to a macOS-like desktop User-Agent, making iPads look like Macs in UA analysis. Use touch-device detection alongside UA for accurate device classification.

⚠Chrome on iOS is not Chrome engine

CriOS (Chrome on iOS) uses Safari’s WebKit engine because Apple requires it. A "Chrome" UA on iOS behaves like Safari for rendering, which affects compatibility decisions.

⚠User-Agent freezing in modern browsers

Chrome and Edge are deprecating detailed UA strings in favor of User-Agent Client Hints (Sec-CH-UA-*). Detailed version info from UA alone may not be available — use Client Hints where detail matters.

⚠Legacy IE very different

IE 10 and earlier use "MSIE N" tokens; IE 11 uses "Trident/[version]". Modern UA parsers still handle these, but they are vanishingly rare in real traffic.

⚠Generic "Mobile" not enough

The Mobile token doesn’t distinguish smartphone from tablet from smart TV. Combine with screen-size and touch capability for accurate device type.

⚠Bot detection is imperfect

Bots can and do spoof legitimate User-Agent strings. Robust bot detection combines UA with DNS reverse lookup (for search engines), behavioral analysis, and rate limiting.

User Agent Parser — comparisons and alternatives

Compared to UAParser.js running in code, this tool is the interactive version — paste a UA, see the breakdown. For server-side parsing at scale, use the library directly in your app.

Compared to analytics tools (Google Analytics), this tool gives the raw parsing on your own UA strings without uploading data. GA aggregates server-side; this tool processes what you paste.

Compared to online UA lookup sites, this tool runs in your browser with no tracking. Other sites may log the UAs you look up; this one does not.

Frequently asked questions about the User Agent Parser

▶What is a User-Agent string?

A text string that every browser sends with HTTP requests identifying itself to the server. It typically includes browser name, version, operating system, and rendering engine in a historically messy format. Servers use it for analytics, responsive serving, and compatibility decisions — not for security.

▶Why do all browser User-Agents contain "Mozilla"?

Historical cargo culting. In the 1990s, servers gave better pages to browsers with "Mozilla" in their UA. New browsers added the token to get the same treatment. Now every browser includes it (Chrome, Safari, Edge, Firefox) for no actual functional reason. The web doesn’t change easily.

▶Can I trust User-Agent for security decisions?

No. User-Agent strings can be set to any value by any client. Bots commonly spoof legitimate browser UAs, and anyone can change their UA with a command-line tool, browser extension, or custom HTTP client. Use UA for analytics and non-security feature detection only.

▶How accurate is version detection?

For traditional UAs, very accurate — regex patterns identify exact major and minor versions. For User-Agent freezing in modern Chrome/Edge, detailed versions are obfuscated to major-version-only. For exact versions, use the User-Agent Client Hints API (Sec-CH-UA-Full-Version).

▶What is User-Agent Client Hints?

A modern replacement for UA strings where servers request specific information via HTTP headers (Sec-CH-UA-* request-response dance). More privacy-respecting and structured than UA parsing. Currently adopted by Chromium browsers. Traditional UA parsing still works but will become less detailed over time.

▶How do I identify a Googlebot?

Check the User-Agent contains "Googlebot" and verify via DNS reverse lookup that the IP resolves to googlebot.com. UA alone can be spoofed, but DNS lookup for the requesting IP catches spoofers. Similar verification exists for Bingbot and other search crawlers.

▶Can I parse User-Agents at scale?

Yes. The tool’s batch mode handles thousands of UAs at once. For server-side analysis, use UAParser.js, ua-parser-js, or similar libraries — they use the same patterns this tool uses and run as part of your application code.

▶Are User-Agent strings privacy-sensitive?

They can be. Detailed UA strings (old desktop browsers especially) contribute to browser fingerprinting, which can identify users across sites without cookies. That is why modern browsers are freezing UA values — to reduce fingerprinting surface. If you log UAs, treat them as PII-adjacent.

Additional resources

Advertisement

Related tools

All Web Tools
🔌

API 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

Next.js App Router: A Complete Beginner Tutorial

26 min read

How to Decode a JWT: A Practical Debugging Guide (with the Base64URL Gotcha Nobody Warns You About)

17 min read

UUID v4 vs v7: The Default Has Quietly Changed

22 min read

Explore more tools

200+ free tools that run in your browser.

Browse all tools →