User-Agent Parser

User-Agent Parser - Analyze and Detect Browser Information

The User-Agent header is the small identifying string every HTTP client sends with each request to tell the server what software is asking. It looks like 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' — a layered, intentionally-confusing format that grew accidentally over 30 years as each new browser tried to identify as the previous dominant one for compatibility (every modern browser still pretends to be Mozilla and most still claim WebKit/Safari heritage even when running Chromium or Gecko). Underneath the ceremony, four useful pieces of information are typically present: the BROWSER (Chrome, Firefox, Safari, Edge, Opera, Brave, Samsung Internet, plus crawlers like Googlebot/Bingbot/GPTBot), its VERSION (major.minor that often correlates with security patch level), the OPERATING SYSTEM (Windows 11, macOS Sonoma, iOS 17, Android 14, Linux distros, ChromeOS), and the DEVICE FORM-FACTOR (desktop / phone / tablet / smart TV / bot). This parser extracts all of these from any UA string you paste, plus the underlying rendering ENGINE (Blink for Chromium browsers, Gecko for Firefox, WebKit for Safari, Trident/EdgeHTML for legacy MS). Click 'Use My User-Agent' to inspect what YOUR current browser sends. Useful for analytics dashboards, bug-report triage, log-line investigation, content-blocker development, and confirming server-side detection rules behave as expected.

What is a User-Agent string?

A User-Agent (UA) string is a text identifier that browsers and other clients send to web servers with every HTTP request. It contains information about:

- Browser name and version (Chrome 120, Firefox 121, Safari 17)
- Operating system and version (Windows 11, macOS 14, Android 13)
- Device type (desktop, mobile, tablet)
- Rendering engine (Blink, Gecko, WebKit)
- Platform architecture (x64, ARM)

Servers use this information to deliver appropriate content, detect capabilities, and provide optimized experiences for different browsers and devices.

How do I use this User-Agent Parser?

Using the parser is simple:

1. Click 'Use My User-Agent' to auto-fill your current browser's User-Agent
2. Or paste any User-Agent string into the input field
3. Click 'Parse' to analyze the string
4. View detailed information about browser, OS, device, and platform

The tool automatically detects and extracts all relevant information from the User-Agent string.

What information can be detected?

The parser extracts:

- Browser: Chrome, Firefox, Safari, Edge, Opera, Internet Explorer, and more
- Browser Version: Major and minor version numbers
- Operating System: Windows, macOS, Linux, Android, iOS, ChromeOS
- OS Version: Specific version numbers when available
- Device Type: Desktop, Mobile, Tablet, or Bot/Crawler
- Platform: Architecture and platform details
- Rendering Engine: Blink, Gecko, WebKit, Trident

All information is parsed from the User-Agent string format.

Why do websites need User-Agent information?

Websites use User-Agent data for:

- Content Optimization: Serve mobile or desktop versions
- Compatibility: Apply browser-specific fixes or features
- Analytics: Track browser and OS usage statistics
- Security: Detect and block malicious bots
- Testing: Verify cross-browser compatibility
- Progressive Enhancement: Enable features based on capabilities
- A/B Testing: Test different versions for different browsers

However, User-Agent sniffing should be used carefully as it can be unreliable. Feature detection is often preferred for determining browser capabilities.

Can User-Agent strings be spoofed?

Yes, User-Agent strings can be easily modified or spoofed:

- Browser extensions can change the User-Agent
- Developer tools allow custom User-Agent strings
- Automated tools and bots often fake User-Agents
- Privacy-focused browsers may use generic User-Agents

Because of this:
- Never rely solely on User-Agent for security
- Don't use it for critical decision-making
- Consider it as a hint, not definitive proof
- Use feature detection when possible
- Combine with other detection methods for important checks

User-Agent is best used for analytics, content optimization, and general device detection, not for authentication or security.

What are Client Hints and why are they replacing User-Agent strings?

User-Agent strings are a privacy and reliability liability: they expose more info than analytics needs, enable fingerprinting (the combination of UA, screen size, fonts, timezone uniquely identifies most browsers), and are easily spoofed. Since 2020 Google has been gradually freezing the User-Agent string in Chrome (removing minor version numbers, exact OS versions, and device model) and replacing it with User-Agent Client Hints (UA-CH), a new system standardised as RFC 9651 in 2023. The server sends an Accept-CH response header listing which hints it wants ('Accept-CH: Sec-CH-UA-Platform-Version, Sec-CH-UA-Model'), and on the next request the browser sends ONLY those specific data points as separate Sec-CH-UA-* request headers. This gives sites the data they actually use while limiting passive fingerprinting. Default hints (sent always) include Sec-CH-UA (low-entropy brand list), Sec-CH-UA-Mobile (boolean), Sec-CH-UA-Platform (OS family). High-entropy hints require explicit Accept-CH opt-in. Firefox and Safari are slower to adopt but follow similar patterns. For UA parsing, this means: in 2025-2026 the User-Agent string is becoming progressively less informative, and modern analytics must consume the Sec-CH-UA-* headers alongside it.

How do I detect bots and crawlers from User-Agent strings?

Most legitimate crawlers identify themselves clearly. Common identifiable patterns: 'Googlebot' (Google Search), 'Bingbot' (Bing), 'YandexBot' (Yandex), 'Baiduspider' (Baidu), 'DuckDuckBot' (DuckDuckGo), 'facebookexternalhit' (link previews), 'Twitterbot' (link previews), 'LinkedInBot' (link previews), 'GPTBot' / 'OAI-SearchBot' (OpenAI training and ChatGPT browsing), 'ClaudeBot' / 'anthropic-ai' (Anthropic Claude), 'Google-Extended' (Bard/Gemini training opt-out), 'CCBot' (Common Crawl, feeds many AI datasets). All of these contain 'bot', 'crawler', 'spider', or 'fetcher' substrings somewhere — a case-insensitive regex /bot|crawler|spider|fetcher|wget|curl/i catches >95% of them in a single pass. For verification (some malicious actors fake legitimate bot UAs to bypass paywalls), always combine UA matching with reverse DNS validation: Googlebot's IPs reverse-resolve to *.googlebot.com or *.google.com; impostors will fail this check. The User-Agent alone is a hint, not a credential.

Once you have identified WHICH bot it is (this tool now names the bot and its category — Search, AI, Social, SEO, or Generic), act on it: ALLOW reputable search crawlers (Googlebot, Bingbot) so your pages stay indexed; decide deliberately on AI crawlers (GPTBot, ClaudeBot, CCBot, Google-Extended) — block them in robots.txt if you do not want your content used for model training; RATE-LIMIT aggressive SEO crawlers (AhrefsBot, SemrushBot, MJ12bot) that can spike server load with little SEO benefit to you; and treat generic clients (curl, python-requests, headless browsers) on sensitive endpoints as potential scraping/abuse worth challenging or throttling.

Why do Edge, Opera, Brave and Vivaldi show up as Chrome in the User-Agent?

Because they are all Chromium-based: Edge, Opera, Brave, Vivaldi, Arc, Samsung Internet and others ship Google's Blink engine, so their User-Agent always contains 'Chrome/<version>' for compatibility. Each then appends its own token AFTER the Chrome token — 'Edg/' for Edge, 'OPR/' for Opera, 'SamsungBrowser/' for Samsung Internet — and this parser checks those tokens first to report the correct brand. Two important catches: (1) Brave and Vivaldi do NOT add a distinguishing token to the standard User-Agent on purpose (Brave strips it for anti-fingerprinting), so from the UA string alone a Brave or Vivaldi browser is genuinely indistinguishable from plain Chrome — there is no reliable UA-only way to detect Brave; you must use the navigator.brave JS API or User-Agent Client Hints (Sec-CH-UA lists 'Brave' as a brand). (2) The Chrome version number these browsers report is the underlying Chromium version, not the browser's own release number. Treat 'Chrome' in analytics as 'Chromium-family' unless a more specific token is present.

How do I tell Windows 11 from Windows 10 in a User-Agent string?

You cannot — not from the legacy User-Agent string. Microsoft froze the Windows token at 'Windows NT 10.0' for BOTH Windows 10 and Windows 11, which is why this parser shows the OS version as '10/11'. There is no Windows 11 value in the classic UA. To distinguish them you must use User-Agent Client Hints: request the high-entropy hint Sec-CH-UA-Platform-Version (send 'Accept-CH: Sec-CH-UA-Platform-Version' and read the returned header, or call navigator.userAgentData.getHighEntropyValues(['platformVersion']) in JS). A returned platform version of 13.0.0 or higher means Windows 11; 1.0.0 through 12.x maps to Windows 10. Any analytics or QA flow that needs the real Windows release must collect this Client Hint rather than parse the UA string.

Is my data safe?

Yes, your data is completely safe:

- All parsing happens in your browser
- No data is sent to any server
- We don't store or log any User-Agent strings
- Works completely offline after page load
- No tracking or analytics on the data you parse
- Open-source client-side processing

You can verify privacy by checking your browser's network tab - no requests are made when parsing User-Agents.

Key Features

• Parse any User-Agent string
• Auto-detect your current browser's User-Agent
• Extract browser name and version
• Detect operating system and version
• Identify device type (desktop, mobile, tablet, bot)
• Name the specific bot/crawler (Googlebot, GPTBot, ClaudeBot, AhrefsBot...) and its category (Search/AI/Social/SEO)
• Show rendering engine information
• Display platform architecture
• Copy User-Agent string to clipboard
• Support for all major browsers and platforms
• Dark mode support
• 100% client-side processing - data never leaves your browser
• Works offline after initial load
• No registration required
• Mobile-friendly responsive design