User Agent & Browser Information – Complete Guide to UA Strings and Client Hints

User-agent questions come from two directions. A web developer sees a bug that only happens "on some phones" and needs to know exactly what the visitor's browser reports. An administrator finds thousands of requests from an unfamiliar string in an access log and wants to know whether it is a browser, a crawler, a monitoring service or a script. Both need the same skill: reading a user agent correctly and knowing which parts are meaningful.

The User Agent tool covers both. The My browser tab shows what your browser reports about itself, device, screen, locale, preferences and capabilities, with every value labelled by where it came from. The Analyze a user agent tab parses any string you paste, for example from server logs.

What is a user agent?

In simple terms

A user agent is the software acting on your behalf when you visit a website: usually a browser, sometimes a crawler, app or command-line tool. With every HTTP request it sends a User-Agent header that names itself. Websites use that text to count browsers, work around bugs and recognize bots. Because the text is self-declared, it is a description, not proof.

Technical background

The header is defined in HTTP semantics (RFC 9110, section 10.1.5) as a list of product tokens with optional versions and comments, such as Chrome/129.0.0.0 or (Windows NT 10.0; Win64; x64). Real browser strings are layered with historical compatibility tokens: Mozilla/5.0, AppleWebKit/537.36 (KHTML, like Gecko) and Safari/537.36 appear in Chrome's string even though Chrome is not Safari. A parser therefore has to look for the most specific token first, for example Edg/ before Chrome/, and Chrome/ before Safari/.

Since 2022 Chromium browsers send a reduced user agent: minor, build and patch versions are frozen to 0.0.0, the OS version is frozen (Windows always reports Windows NT 10.0, macOS reports 10_15_7), and on Android the device model is replaced with K. The detailed values moved to User-Agent Client Hints: navigator.userAgentData exposes low-entropy brands, platform and a mobile flag, and getHighEntropyValues() can return the full version list, architecture, bitness, model, platform version and more. Firefox and Safari do not implement Client Hints, so for them the string is all there is. See the MDN reference for User-Agent Client Hints.

Everything else a page can learn about the environment comes from standard APIs: screen and window sizes, devicePixelRatio, matchMedia() media features (color scheme, reduced motion, pointer type), Intl for locale and time zone, the Permissions API for permission states, and simple existence checks for features such as WebGPU or Web Serial.

Why use the User Agent tool?

• Reproduce browser-specific bugs. Get the exact browser, version, engine, OS, viewport and pixel ratio from a user who reports a problem; they can copy a summary or JSON export.
• Identify unknown clients in logs. Paste a string to see whether it is a browser, an in-app WebView, a headless browser, a search or AI crawler, an uptime monitor, or a command-line client such as curl or wget.
• Understand reduced data. See which values your browser freezes or withholds, and what Client Hints add.
• Check capabilities. Before relying on an API, see whether a given browser supports it and whether it needs a secure context.
• Review privacy signals. See whether Global Privacy Control or Do Not Track are sent, and whether automation (WebDriver) is flagged.

Who should use it?

• Front-end and web developers debugging layout, media or API support on specific devices.
• Support teams collecting environment details from users.
• System administrators and SREs reading access logs, rate-limiting bots or writing crawler rules.
• QA engineers verifying test devices and automation setups.
• SEO practitioners checking how search and AI crawlers identify themselves.

How the User Agent tool works

The whole tool runs in your browser. The page reads navigator.userAgent and parses it locally with a lightweight parser that knows common browsers, engines, operating systems, device types, search engines, AI crawlers, social preview bots, SEO crawlers, monitoring services, command-line clients and HTTP libraries. In Chromium browsers it also reads low-entropy Client Hints and requests high-entropy values once (architecture, bitness, model, platform version, full version list, WOW64 and form factors); the browser may decline. Brave is recognized through navigator.brave, because Brave sends Chrome's exact string.

Every value carries a source label:

• Reported – read directly from a browser API.
• Client hint – from User-Agent Client Hints.
• Parsed – extracted from the user-agent string.
• Calculated – computed on the page (for example physical pixels = screen × pixel ratio, or the UTC offset).
• Estimate – a coarse value the browser itself rounds, such as navigator.deviceMemory or the Network Information API.

The page asks for no permission. Permission states are read with navigator.permissions.query(), which never prompts. Storage is checked by access only; nothing is written. WebGL support is tested by creating a context without reading the renderer, and the media table uses canPlayType() without playing anything. No canvas, audio, font or WebGL fingerprint is computed. Values update on browser events (resize, orientation, online/offline, color-scheme changes); the clock ticks once a second only while the tab is visible.

What the page does not control: your browser sends the User-Agent header with every request to every site, including this one, as part of normal page delivery.

How to use the NetTools.tech User Agent tool

1. Open User Agent. The My browser tab fills in automatically.
2. Read the identity card (browser, major version, OS, device, architecture, engine, screen and language) and the overview cards below it.
3. Scroll through the grouped sections; hover a label to see which API the value comes from.
4. Use Raw user agent to copy the exact string, copy it as JSON with the parsed result, or press Analyze to open it in the analyzer.
5. Filter the Feature detection table by name, category or support status.
6. Use Copy summary, Copy JSON, Download JSON or the export bar (CSV, JSON, Copy all, Print) to share the report.
7. To check another string, switch to Analyze a user agent, paste it into the User-agent string field and press Analyze. Use my browser fills in your own string, Clear resets, and the example chips (iPhone Safari, Android Chrome, Googlebot, GPTBot, curl) show typical results.

Understanding the results

Example: analyzing strings from an access log

Pasting the reduced Chrome string Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 into the analyzer gives:

Client type:        Web browser
Browser:            Chrome 129.0.0.0      Browser family: Chrome
Version components: 129 . 0 . 0 . 0
Rendering engine:   Blink 129.0.0.0
Operating system:   Windows 10 / 11
Device type:        Desktop
CPU architecture:   x86-64
What this string cannot tell:
- Windows 10 and 11 both report "Windows NT 10.0"; only User-Agent Client Hints can tell them apart.
- Reduced user agent: the minor, build and patch versions are frozen to 0.
- Brave and some other Chromium browsers send exactly the same string as Chrome.

The string curl/8.7.1 is classified as Command-line client, device type Command-line / server client, detected client curl 8.7.1. The Googlebot example is classified as Bot / crawler — Search engine crawler with the detected crawler Googlebot 2.1. Whether that request really came from Google is a separate question the string cannot answer.

Common use cases

• Asking a user to open the page and send the JSON export when a bug only reproduces on their device.
• Classifying unknown entries in web server logs before writing rate limits or bot rules.
• Checking which AI crawlers and search bots appear in logs before adjusting robots.txt.
• Confirming that a test automation browser exposes navigator.webdriver, or that a kiosk device reports the expected viewport.
• Comparing media codec support across browsers before choosing a video format.

Troubleshooting

The browser name is wrong (for example Chrome instead of Brave or Vivaldi)

Several Chromium browsers send exactly Chrome's string. The page detects Brave through navigator.brave; others cannot be distinguished from the string. Client Hints brands sometimes help.

The OS version looks outdated

Frozen values are expected: Windows NT 10.0 for both Windows 10 and 11, macOS 10.15.7 regardless of the real version. In Chromium browsers check the Client Hints platform version; Firefox and Safari do not provide it.

Many fields say "Not supported"

Firefox and Safari implement fewer of the optional APIs (Client Hints, Network Information, Battery, device memory). Some APIs also require HTTPS. This is normal.

The analyzer says no known tokens were found

The string contains no recognizable browser, OS, crawler or client token. That is common for custom scripts and internal services and is not necessarily malicious. Look for a contact URL in the string or check the source IP with IP Lookup.

Screen size does not match my monitor's resolution

Screen values are in CSS pixels. Multiply by the device pixel ratio (shown as "Physical pixels (calculated)"); browser zoom changes the ratio.

Common mistakes

• Blocking or trusting traffic based on the user agent alone. It is trivially spoofed.
• Reading Safari or Mozilla in a string as the actual browser.
• Treating Chrome/129.0.0.0 as a precise version; in reduced UAs only the major version is meaningful.
• Assuming the language or time zone reveals the user's country.
• Interpreting "Normal browser" in the automation section as proof that a visitor is human.

Limitations

• The parser is token-based and best effort; new or unusual clients may be misclassified or unknown.
• Reduced user agents hide minor versions, real OS versions and Android device models; only Client Hints recover some of that, and only in Chromium browsers.
• Desktop and laptop cannot be distinguished, and iPads in desktop mode report a Mac user agent.
• Hardware values (cores, memory) are what the browser chooses to report, not physical specifications.
• Third-party cookie restrictions cannot be reliably detected from a first-party page and are shown as not available.
• Bot detection names the crawler a string claims to be; it does not verify the claim.

Security & privacy

The tool processes everything locally. Values shown and strings pasted into the analyzer are not sent to or stored on the NetTools server, and the page requests no permission. Exports contain only what is on the page; parameters in the current URL that look like tokens, sessions or keys are masked, and the referrer is shown only as present or absent. As with any website, your browser sends its User-Agent header when loading the page, and the web server's standard access logs are kept as described in the privacy policy.

User-agent strings from logs can contain internal hostnames, app identifiers or customer IDs inside custom tokens. Parsing happens in your browser, but review exports before sharing them.

Related tools

• My IP – the other half of what a website sees about you. Guide: What is my IP.
• HTTP Status Checker – see how a server answers a request. Guide: HTTP Status guide.
• Robots.txt AI Crawler Policy – check which AI crawlers a site allows. Guide: AI crawler policy guide.
• Robots.txt Checker – test crawler rules for search bots. Guide: Robots.txt guide.
• MAC Lookup – identify hardware vendors on your local network.
• Overview: My Info & Identity tools.

Summary

The User Agent tool shows what your browser reports, with each value labelled as reported, parsed, calculated, a client hint or an estimate, and parses any user-agent string you paste. Modern browsers freeze and reduce the string on purpose, so read the notes and Client Hints before drawing conclusions. Everything runs locally, and a user agent should only ever be treated as a hint, never as proof of identity or device.