Parsed client profile
{{ summaryTitle }}
{{ summaryLine }}
{{ badge.value }}
Default parses immediately. Header blocks are supported, and Use current UA also checks Client Hints when this browser exposes them.
Parsing updates locally as the source, input shape, or review controls change.
Choose Header block when pasted request text must contain a User-Agent line.
Review focus:
{{ focusHelp }}
Use Broad for log triage; use Strict when avoiding false positives matters most.
Controls summary, profile, review-note, and JSON version formatting.
Field Value Evidence Copy
{{ row.field }} {{ row.value }} {{ row.evidence }}
Position Token Type Meaning Copy
{{ row.position }} {{ row.token }} {{ row.type }} {{ row.meaning }}
Signal Status Note Copy
{{ row.signal }} {{ row.status }} {{ row.note }}
Check Status Evidence Copy
{{ row.check }} {{ row.status }} {{ row.evidence }}
Use Recommendation Copy
{{ row.use }} {{ row.recommendation }} 
{{ formattedJson }}
Tags: Devtools, Diagnostics, HTTP
Export to PDF Fullscreen
Customize
Advanced
:

A User-Agent value is the client description sent with many HTTP requests. It usually combines browser product tokens, rendering-engine hints, operating-system clues, device comments, and compatibility phrases that have accumulated over decades of web compatibility work.

User-agent parsing helps support teams reproduce browser issues, helps analytics teams group traffic, and helps site operators triage crawler or automation traffic. The result should be treated as a set of hints, not a verified identity. Browsers can reduce or freeze parts of the value, users and tools can spoof it, and many crawlers announce themselves only by convention.

User-Agent string split into product tokens, platform comments, bot hints, and confidence checks

Classic user-agent strings are still common in server logs, access reports, browser support tickets, and security reviews. Their format is useful because one copied line can carry browser, engine, platform, device, and bot clues. Their weakness is the same property: one copied line can also be stale, reduced, invented, or copied from another client.

For compatibility work, user-agent parsing should guide the next test rather than replace it. Feature detection, Client Hints, viewport checks, DNS verification for named crawlers, and request-rate evidence all give stronger confirmation when the decision has support, analytics, or blocking consequences.

How to Use This Tool:

Paste one value from a ticket, log row, or copied request. The parser updates the summary, profile rows, token map, bot signal, and review notes from the same input.

  1. Paste the value into User-agent string, choose Use current UA, or load a desktop, mobile, or bot sample. Header blocks are accepted, but the result is for one User-Agent value only.
  2. Set Input shape. Auto-detect raw UA or header block extracts a visible User-Agent header when present, Raw user-agent string only reads the first non-empty line, and HTTP headers with User-Agent requires a matching header line.
  3. Choose Review focus. Support writes ticket-oriented guidance, Analytics emphasizes grouping browser, operating system, device, and bot traffic, and Bot review emphasizes crawler and automation checks.
  4. Set Bot detection. Strict looks for named crawlers, Balanced also flags common crawler and preview terms, and Broad includes common command-line clients, HTTP libraries, API clients, and headless browser clues.
  5. Open Advanced only when version grouping matters. Full version strings keeps issue-report detail, while Major versions only makes analytics notes easier to group.
  6. Read Profile Snapshot first, then use UA Token Map, Bot & Compatibility, and Client Hint Check to see the evidence behind the summary. The focus-specific tab provides the follow-up notes for the selected review purpose.
  7. If the result shows Input needs a user-agent, No User-Agent header was found, or an ignored extra-line warning, fix the pasted text before using the profile rows as evidence.

A good handoff keeps the raw value, Source shape, Browser, Operating system, Device class, Bot signal, Client Hint Check notes when available, and the relevant review note together.

Interpreting Results:

Start with the profile rows, not the headline alone. Browser, Rendering engine, Operating system, and Device class are useful reproduction clues when the evidence row names a matching product or platform token. Unknown means the value did not expose enough detail for that field, not that the client lacks a browser, operating system, or device.

Result cue Best reading What to verify
Profile Snapshot Readable browser, engine, platform, device, CPU, bot, and source-shape fields. Confirm exact behavior in the affected browser before treating a version clue as the cause.
UA Token Map Product and comment tokens split into browser, engine, platform, crawler, compatibility, product, or comment categories. Check the token evidence when a profile field looks surprising or too generic.
Bot & Compatibility Named crawler, automation, sparse-token, Client Hints, and security caveat rows. Verify crawler identity with IP, DNS, published ranges, request rate, and behavior before allowing or blocking traffic.
Client Hint Check Current-browser UA-CH availability, brand, platform, mobile, architecture, and model evidence when the browser exposes it. Compare only when the parsed value is the current browser UA; pasted log values need server-side Sec-CH-UA evidence.
Review notes Purpose-specific next steps for support, analytics cleanup, or bot review. Keep the selected focus stable when comparing two parsed values.

False confidence is the main risk. A user-agent can claim Chrome, Safari, Googlebot, or a mobile device without proving it. Use feature checks for browser compatibility, User-Agent Client Hints when more structured browser detail is available, and crawler verification when traffic policy depends on the result.

Technical Details:

The HTTP User-Agent field is a sequence of product identifiers and optional comments. Product identifiers usually appear as names with optional versions, while comment blocks often carry operating-system, CPU, mobile, compatibility, or device-model clues. Many browser strings also retain historical compatibility tokens such as Mozilla/5.0, AppleWebKit, KHTML, like Gecko, and Safari because old server-side sniffing logic expected them.

Modern browser strings expose less detail than older ones. User-Agent reduction can freeze exact operating-system versions, device models, and minor browser versions. User-Agent Client Hints move some of that detail into structured values that a site can request and the browser can choose to share. A parsed classic string is therefore a useful starting point, especially for copied logs, but it is not always the most precise browser inventory available.

Transformation Core

The parsing path first chooses one User-Agent value, then normalizes the profile fields, splits the visible tokens, and applies crawler or automation checks according to the selected sensitivity.

Input setting Accepted text Selection rule Failure or warning
Auto-detect Raw value or copied request headers. Uses a User-Agent header line when present; otherwise uses the first non-empty line. Extra non-empty lines are ignored and reported as a warning.
Raw string One classic user-agent value. Uses the first non-empty line exactly as the candidate value. Empty input asks for a pasted value or a sample.
Header block One or more HTTP request header lines. Requires a line whose header name is User-Agent. Missing header line produces the no-header error.

Token and Field Map

Token classification is evidence-oriented. It explains which parts of the original string support a browser, engine, platform, compatibility, crawler, or product reading.

Token category Typical examples Meaning in the result
Browser Chrome/124, Firefox/125, Edg/124, Version/17.5. Supports the Browser and Browser version rows.
Engine AppleWebKit/537.36, Gecko/20100101, Trident/7.0. Supports the Rendering engine row or explains compatibility naming.
Platform Windows NT 10.0, Mac OS X, Android, iPhone, x64. Supports Operating system, Device class, Device model, and CPU arch.
Crawler Googlebot, Bingbot, Slackbot, curl, HeadlessChrome. Feeds Bot signal and the bot-review recommendations.
Compatibility Mozilla/5.0, KHTML, like Gecko, browser compatibility phrases. Explains historical tokens that should not be read as literal browser identity.

Bot Signal Rules

Bot detection is a text-pattern triage step. It is useful for reviewing logs, but it does not authenticate the client.

Sensitivity Matches included Best use Main limit
Strict Named crawlers and known preview clients. Reduce false positives when reviewing ordinary browser traffic. Automation clients without known names may remain unflagged.
Balanced Named crawlers plus generic crawler, preview, scanner, and monitor terms. Normal access-log triage where crawler wording matters. Generic words can still appear in custom or copied strings.
Broad Balanced matches plus command-line clients, HTTP libraries, API clients, and headless browser terms. Find automation and scripted requests during incident or traffic review. API clients can be legitimate, so blocking needs stronger evidence.

Worked Mechanism Path

A pasted three-line header block with Host, User-Agent: Mozilla/5.0 ... Chrome/124.0.0.0 ..., and Accept in Auto-detect mode becomes one extracted user-agent value. The profile rows then identify browser and platform clues, the token map lists each product and comment token in order, and Bot & Compatibility reports no crawler match unless the string contains a named crawler, generic crawler term, or automation token selected by the current sensitivity. Client Hint Check separately reports whether this browser session exposes structured UA-CH values that can cross-check the current browser UA.

Privacy and Accuracy Notes:

The pasted value is analyzed in the browser session and is not submitted to a lookup service by this parser. The page can still load normal page assets, so do not treat the browser session as a secure evidence vault.

  • Header blocks copied from logs can contain IP addresses, session identifiers, private hostnames, or internal notes. Keep only the User-Agent value when sharing a result outside a trusted support context.
  • Reduced browser strings can hide exact platform versions, device models, or minor browser versions. Compare Client Hints or an in-browser diagnostics report when exact device detail matters.
  • A crawler name is a claim. For traffic policy, verify source IP, reverse and forward DNS, published crawler ranges, robots behavior, and request cadence.
  • Use feature detection for compatibility decisions that affect real users. A parsed browser name alone can miss extensions, enterprise policy, privacy settings, viewport differences, and unsupported APIs.

Worked Examples:

Support ticket for a desktop browser

A copied value such as Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 produces a Profile Snapshot with Chrome, macOS, a desktop or unknown device class, and a no-crawler bot signal. Use the Ticket summary and Compatibility next check rows to reproduce the issue in a matching browser first, then compare another engine if the bug looks rendering-specific.

Crawler log review

A log line containing Googlebot/2.1 makes Bot signal show Googlebot in Balanced mode, and Bot Review recommends keeping the raw value, source IP, timestamp, requested URL, and token map. That is enough for a triage note, not enough for an allow-list decision. Verify the IP and DNS relationship before treating the request as genuine Google crawling.

Header block missing the field

If Input shape is set to HTTP headers with User-Agent and the pasted block only contains Host and Accept, the summary changes to Input needs a user-agent. The Profile Snapshot shows Input status as needing edit, so the corrective path is to paste the original request headers or switch to raw mode with one actual User-Agent value.

Analytics grouping with reduced detail

A Chrome string that reports a major version but freezes minor versions can still group under the detected browser and operating system. Choose Major versions only when the report is about traffic mix, and keep Full version strings when a regression ticket needs the exact visible version token.

FAQ:

Can a user-agent prove which browser made the request?

No. The value is self-reported and can be reduced, spoofed, or copied. Use Profile Snapshot for support clues, then confirm important compatibility decisions with feature checks or Client Hints.

Why were extra pasted lines ignored?

The parser works on one User-Agent value at a time. In raw mode or auto-detect without a header line, it reads the first non-empty line and reports the ignored extra lines as a warning.

Why is the device model unknown?

Many browser strings do not expose model detail, and reduced strings may deliberately hide it. Check UA Token Map for platform clues and use Client Hints or a browser diagnostics report when model detail is required.

Should I use Strict, Balanced, or Broad bot detection?

Use Strict when false positives matter most, Balanced for routine crawler triage, and Broad when you also want command-line clients, HTTP libraries, API clients, and headless browser clues flagged for review.

Does using the current browser value send my user-agent away for parsing?

No. Use current UA reads the browser's own visible value and the parsing happens in the page session. Review copied header blocks before sharing because they may contain more than the User-Agent value.

Glossary:

User-Agent
The HTTP request value that identifies the client software and related compatibility details.
Product token
A name and optional version segment such as Chrome/124 or AppleWebKit/537.36.
Comment block
A parenthesized part of the string that often carries platform, CPU, mobile, or compatibility clues.
User-Agent Client Hints
Structured browser and platform hints that a site can request when more precise user-agent detail is needed.
Crawler
An automated client that requests pages for search, preview, monitoring, indexing, or similar non-human browsing tasks.
Feature detection
Checking whether the browser supports a specific web capability instead of assuming support from its name or version.

References: