DeviceBenchFree user agent checker
Your user agent, and the version it stopped telling you
The block at the top is the exact User-Agent header this browser sends to every site you open, with the Client Hints brand list Chromium sends alongside it and the real build number the header no longer carries. Twelve capabilities underneath — WebGL, WebGPU, WebRTC, WebAssembly, service workers and the rest — are probed by asking for the feature itself, because a UA string has never been evidence that anything works. Copy hands you all of it as one plain-text block.
- 100% free
- No signup
- Full UA string
- 12 capabilities probed
- Copy as one block
How to read what your browser is announcing
Three passes: the string, the brands that replaced half of it, then the capabilities nobody should infer from either.
Read the string, then read the two versions under it
The dark block is your User-Agent header, character for character, as every site you open receives it. Underneath sit two version readings: the one written into that string and the one the Client Hints report. On Chromium they disagree, and the second is the true build — the string has carried a fake 0.0.0 tail since Chrome 110 and the label says which reading is which.
Check the brand list before you trust any of it
Chromium sends a short brand list next to the header, and one of its entries is invented on purpose — a rotating nonsense brand with a name like Not(A:Brand, put there so that code cannot hard-code the list and break when it changes. If the brand panel says nothing was sent, you are in Firefox or Safari, neither of which implements Client Hints, and the string is genuinely all the information there is.
Probe the capabilities, then copy the block
Each of the twelve capability rows was tested by asking for the thing itself: a WebGL row means a context was really created and then released, not that the word Chrome appeared somewhere. Press Copy the full report and you get a plain-text block — string, brands, locale, storage, capabilities present and capabilities missing — which is what a maintainer means when they ask what browser you are on.
Technical specifications
| Source of the string | navigator.userAgent, byte for byte the same value sent in the User-Agent request header |
|---|---|
| Version freeze | Chrome 110 pinned the minor, build and patch digits to 0.0.0; the major number still increments with each release |
| Client Hints brands | navigator.userAgentData.brands, including one intentionally fabricated GREASE entry so that parsers cannot hard-code the list |
| Real build number | getHighEntropyValues(['uaFullVersion']), which resolves a frame later on Chromium and never resolves in Firefox or Safari |
| Capabilities probed | 12 — WebGL, WebGL 2, WebGPU, WebRTC, WebAssembly, service workers, Web Audio, Gamepad, Fullscreen, Clipboard write, Web Share, Notifications |
| Storage checks | 5, and the two Web Storage areas are tested with a real write-then-delete because a blocked origin still exposes the object and throws only on write |
| Tracking signals | Do Not Track and Global Privacy Control shown separately — DNT is a request nobody must honor, GPC carries legal force in California |
| What leaves the tab | Nothing. The report is assembled from values the browser already holds, and Copy is the one control that moves any of it anywhere |
Frequently asked questions
Why does my user agent begin with Mozilla/5.0 when I have never used Mozilla?
Because every browser has claimed to be Netscape since 1996 and none of them can stop. Servers of that era sent frames only to browsers whose UA started with Mozilla, so Internet Explorer began announcing itself as Mozilla with an in-brackets note, and each new browser copied the disguise to inherit the content. Thirty years later the prefix is pure sediment: Mozilla/5.0 identifies nothing, and everything meaningful is in the tokens after it.
Why does the version in my string end in 0.0.0?
Chrome deliberately froze it — the change shipped in Chrome 110 and Edge followed. The major number still moves, but the minor, build and patch digits were pinned to 0.0.0 because they were four of the most identifying bits a browser was handing out for free. The exact build now lives only in the high-entropy Client Hints, which a site has to ask for asynchronously, and that request is visible to you in a way the header never was.
Can I change what my browser reports?
Yes, and you will usually be caught. DevTools has a Network conditions override and there are extensions that rewrite the header, but almost none of them rewrite the Client Hints as well, so a site that reads both sees a browser claiming to be Safari on macOS while sending a Chromium brand list. That mismatch is more distinctive than the honest string was, which is the standing joke about UA spoofing: it makes you rarer, not more anonymous.
Does my user agent identify me personally?
On its own, no — millions of people send a byte-identical string. It becomes identifying in combination: the string, the language list, the time zone and the capability answers together narrow a visitor far more than any one of them does, which is what fingerprinting means and why browsers keep taking detail out of this header. The specs, and the reason a browser rounds them, are on the device info page.
Why is the Client Hints panel empty in Firefox?
Firefox and Safari never implemented User-Agent Client Hints. Mozilla called the design harmful and WebKit was similarly unconvinced, so both send the classic header alone and neither answers getHighEntropyValues at all. This is not a fault on your machine: an empty brand panel is the correct, expected reading in those two browsers, and it is also why a site that relies on Client Hints for layout decisions has a bug on a third of the web.
A site says my browser is unsupported, but it is the current version. Why?
Almost always because the site is parsing the frozen part of the string. Code written before 2023 that reads the fourth version segment now sees 0 on every Chromium browser on earth, and a comparison against a required build fails for everybody. Copy the report from this page into the bug you file — the brand list plus the real build number is exactly the evidence that turns that report from a complaint into a reproducible case.
One of the capabilities says no. Is something broken?
Not necessarily, because the probe answers whether the feature is reachable right now rather than whether the browser ships it. WebGPU is absent outside recent Chromium; hardware acceleration switched off in settings takes WebGL down with it; an enterprise policy can remove notifications; a private window disables service workers in some browsers. A no is a fact about this tab as it is currently configured, which is exactly what you want when a site refuses to run in it.
About the user agent string and where the truth moved
The User-Agent header is the oldest identity mechanism on the web and the least honest. It began as a courtesy — tell the server which client is asking — and turned into an arms race within two years, because servers started gating content on it and every browser answered by impersonating the one already being served. That is the entire explanation for the string on this page: Mozilla/5.0 is the ghost of Netscape, AppleWebKit and KHTML, like Gecko are two more layers of the same disguise, and Chrome still says Safari at the end because in 2008 that was the fastest route to being treated as a modern browser. Nothing in the first half of the string is a fact about your machine.
What changed recently is where the accurate part lives. Google measured how much a visitor gives away in that header and concluded the version tail and the platform detail were among the cheapest bits to remove, so from Chrome 110 the string reports a frozen version and a deliberately vague platform, and the precise answers moved into User-Agent Client Hints: a short brand list sent by default, and a getHighEntropyValues() call a site must make explicitly for the full build number, the platform version and, on Android, the model. Two consequences follow, and both are visible on this page. A site that reads only the old string now gets less than it used to, which is why version sniffing broke everywhere in 2023. And Firefox and Safari implement none of it, so in those browsers the reduced string really is the whole answer — which is why the brand panel is empty rather than broken.
Two readings on this page are commonly misread as bugs, and both are the browser working correctly. Every Mac reports Mac OS X 10_15_7 whatever version it is running, frozen since 2021; every Windows machine reports Windows NT 10.0 whether it is Windows 10 or 11, and only platformVersion separates them — the resolved answer, along with the cores, memory and GPU the string never mentioned, is on the device info page. The capability list here is the antidote to both: it does not ask what the browser calls itself, it asks the browser to produce the feature and reports what happened. If the question underneath is whether you have a working connection rather than a working feature, the connection status page answers that one, and what is my screen resolution covers the display numbers that no header has ever carried.
Where this report is built
Every number on this page is worked out by JavaScript running in the tab you are reading it in. Nothing you type, paste or open is uploaded, logged or kept, which is also why the tools carry on working after you disconnect from the network.
The values here are ones your browser was already prepared to hand any site that asked — reading them back to you adds nothing to what you were giving away, and this page keeps no copy. The one thing it does write is a temporary key called devicebench-probe, put into local and session storage and deleted in the same instant, because that write is the only honest way to tell working storage from blocked storage.