User-Agent Parser

Parse browser, OS, device, and engine signals from UA strings

Use User-Agent Parser

Input and output check

User-Agent Parser

Start from the sample input, then inspect the output panes, diagnostics, and structured mapping view before you copy any artifact into production tooling.

Runtime summary

Preparing output

Agent profile
Diagnostics

Output details

Output review

Review these checks before copying generated output into a request, fixture, client, or support note.

Browser family

Start with browser family to confirm the workbench is modeling the same input surface you are debugging.

OS guess

The output pane keeps os guess visible so you can compare the raw input with the derived artifact.

Device hints

Use device hints as the final review pass before shipping the output into a terminal, database, or API client.

Output review rule

Read the parser output as a heuristic profile, then confirm important cases with feature detection where possible.

Sample input to try

Paste the complete User-Agent header from a request log, support ticket, or browser network trace without trimming vendor tokens.

Expected output review

Review browser family, engine hint, operating system, device class, bot indicators, and confidence notes as a heuristic client profile.

Real debugging sample
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36

Expected readout:
browser=Chrome, engine=Blink/WebKit hint, os=Windows, device=desktop, bot=false or not indicated
Common errors to check
  • Using user-agent parsing as an authentication, fraud, or entitlement signal.
  • Ignoring spoofed or privacy-reduced user-agent strings.
  • Trimming compatibility tokens that explain browser or engine detection.
Next checks
  • Use HTTP Header Parser to inspect Accept, Sec-CH-UA, and platform hints beside User-Agent.
  • Use API Request Builder to reproduce the request with relevant client headers.
  • Use HTTP Status Lookup if a compatibility issue appears only with certain clients.
  • Confirm critical behavior with feature detection in the application.
Local processing: Parsing is local; logs around a user-agent string can include IPs, account IDs, URLs, and request IDs that need redaction.
HTTP Header ParserInspect User-Agent with surrounding client headers.API Request BuilderRebuild a request with selected client headers.HTTP Status LookupInterpret status patterns by client profile.OpenAPI Endpoint ExplorerCheck whether the affected endpoint is documented.

Built for support, analytics, and compatibility teams triaging requests from unknown clients. Use this workbench for extracting browser, engine, device, and operating system hints from a user-agent string, then read the diagnostics before copying the artifact into a client, config, import job, or support note.

Audience
support, analytics, and compatibility teams triaging requests from unknown clients
Primary artifact
a client profile summary
Caveat
User-agent parsing is inherently brittle because clients spoof and compress signals over time.
Privacy
Browser-only input, no upload step, copy-ready output.
Browser familyOS guessDevice hints

Request workflow and diagnostics

How The Workbench Is Structured

1. Raw input stays visible

The calculator keeps the original input close to the generated artifact so you can spot transformation drift before you copy anything forward.

2. Diagnostics sit beside output

Each tool pairs the generated output with concise warnings or checks so you do not need to interpret a raw string in isolation.

3. Mapping beats guesswork

The mapping panel highlights the pieces that matter for handoff: headers, query keys, columns, claims, chunk sizes, or file signatures.

The summary panel highlights the request, payload, token, or generated artifact that matters most for this workflow.

How To Use This Developer Workbench

Where User-Agent Parser Fits In The Workflow

User-Agent Parser is built for support, analytics, and compatibility teams triaging requests from unknown clients. The page treats the task as a workbench, not a single conversion box, so the output stays explainable when you hand it to another engineer or paste it into docs.

Inside API & HTTP, the focus is extracting browser, engine, device, and operating system hints from a user-agent string. That is why the page keeps the original input visible alongside the derived artifact and diagnostics.

  • Browser family
  • OS guess
  • Device hints

How To Prepare Inputs

Use the full raw user-agent string from logs or the request header without trimming vendor tokens.

If you are debugging a live issue, start with the exact value captured from logs, docs, or traces before making cleanup edits. That makes the before-and-after result more trustworthy.

Checks Before You Ship The Result

Read the parser output as a heuristic profile, then confirm important cases with feature detection where possible.

User-agent parsing is inherently brittle because clients spoof and compress signals over time.

Request checks before copying output

Questions about this developer tool

What does User-Agent Parser produce?

User-Agent Parser is tuned for extracting browser, engine, device, and operating system hints from a user-agent string. The main output is a client profile summary, supported by diagnostics and a mapping view so you can review the transport or data shape before using it elsewhere.

What input shape works best for User-Agent Parser?

Use the full raw user-agent string from logs or the request header without trimming vendor tokens.

What should I verify before using the output in production?

Read the parser output as a heuristic profile, then confirm important cases with feature detection where possible. User-agent parsing is inherently brittle because clients spoof and compress signals over time.

Developer references and workflow assets

References

  • MDN Navigator.userAgent

    Browser guidance and caveats for user-agent parsing and client identification.

  • HTTP Semantics

    Core HTTP semantics for methods, status codes, headers, and message processing.