User Agent Check

doc

Analyze your User Agent string and UA-CH hints to identify browser engine, OS, and device signals. Spot mismatches in login flows and anti-bot challenges.

The user agent is the single most quoted field in web analytics and one of the least informative. It was designed to describe the browser, and it still does — approximately. What it no longer does is identify a device or a person, and treating it as if it does is the source of most bad conclusions about traffic quality.

Structure of the string

A conventional UA has four parts, stored as one string:

SegmentMeaningReliability
Mozilla/5.0A hard-coded prefix kept for legacy compatibilityMeaningless; present in nearly every string
Platform blockOS family and architecture, in parenthesesApproximate; often omitted now
Engine tokenRendering engine and version, e.g. AppleWebKit, GeckoStable but not useful alone
Browser tokenProduct name and version, e.g. Chrome/138The only part most parsers use

Two facts follow. First, the prefix is fiction: no browser is Mozilla, and every major browser sends it. Second, the trailing token is the only field with routine value, and it identifies a build, not a user.

Why the string shrank

Chrome reduced its UA in 2023 to a reduced form: Mozilla/5.0 (platform) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/<version> Safari/537.36. Detailed device and architecture information moved to Client Hints, which are headers the browser sends only when the site asks for them via Accept-CH. The reduction removed a passive tracking vector without removing the functional capability, because the capability was moved rather than deleted.

Consequences worth knowing:

  • Version granularity is preserved. The major version is still in the string, which is enough to detect "this browser is old" but not to identify a device.
  • Legacy parsers produce worse results. Tools that expected the platform block now see a truncated one, and some infer the wrong OS.
  • Client Hints are opt-in. A site that never sends Accept-CH receives the reduced UA and no hints, so it knows less than it did in 2022.

Why it is not a reliable identity

Three reasons, all structural:

  1. It is a request header, so it can be rewritten. Any proxy, extension or debugging tool can change it, and many do.
  2. It is coarse. Millions of users share one string. It narrows a population, it does not select an individual.
  3. It is stale by design. Many browsers freeze parts of the string for compatibility, so the values describe a nominal configuration rather than the running one.
  4. A UA that looks "fake" is therefore normal. A UA that looks "real" proves nothing. The check is worth running because implausible combinations exist — a version that predates the claimed platform, a platform the browser never supported — but a mismatch is a prompt to look further, not a verdict.

    What a UA check actually examines

    • Parsed browser and version. Which build the string claims, and whether that build exists.
    • Parsed platform. Which OS family the string claims, versus which the client-side probe reports.
    • Consistency with Client Hints. When hints are present, whether the brand list and platform agree with the UA.
    • Plausibility. Whether the claimed combination could exist — a mobile browser on a desktop-only platform, or a version from before a feature shipped.
    • Reduced versus full form. Whether the string is the modern reduced UA or a legacy full one, which hints at the client's age or configuration.

None of these identify a person. They describe a build and a configuration, which is the correct scope.

Practical use

  1. Use it for compatibility, not attribution. Feature detection based on the version is reasonable. Inferring intent from the string is not.
  2. Prefer feature detection over UA sniffing. Modern browsers expose capabilities directly; the string is a fallback.
  3. Do not fight Client Hints. They are the supported replacement. Sites that need device detail should ask, with a clear purpose.
  4. Treat unexpected strings as questions. Ask what configuration would produce this, before concluding anything about the user.

Common misreads

  • "The UA says Windows, so it is a desktop." The string is coarse and freezable. A tablet can report a desktop platform.
  • "The UA does not match my actual browser, so I am compromised." Extensions, corporate proxies and privacy tools rewrite it routinely.
  • "A generic UA means a bot." Generic strings are common among legitimate privacy tools and old devices.
  • "Client Hints replaced the UA, so the UA is useless." It is reduced, not removed, and version information is still present.

FAQ

Is the user agent personally identifying?

No. It identifies a build. Combined with other signals it contributes to a fingerprint, but alone it selects a large population.

Why does my UA not match my browser version?

Browsers freeze or reduce parts of the string for compatibility. The reported version can lag the installed one deliberately.

Can I change it?

In most browsers with extensions or developer settings, yes — which is exactly why it is not trustworthy as an identity signal.

Should sites keep using it?

For compatibility checks, yes. For device identification, Client Hints are the supported path, and even they are opt-in.