A "what browser am I using" report is a transparent readout of the identity fields your browser voluntarily exposes to any web page, including the reported brand list, platform, mobile hint, language, cookie setting, and the raw user-agent compatibility string. Modern browsers decide what to share through User-Agent Client Hints, a structured interface that returns a brand list with major versions, a platform string, and a mobile hint, while older browsers fall back to the long, messy navigator.userAgent compatibility string that websites have read for decades. An honest tool reads both, removes only the well-known meaningless GREASE-style placeholder, preserves the raw user-agent verbatim, and writes a clear "Browser name not exposed" message when the browser does not reveal a useful product name. The aim is to show what the browser chose to report, label it as a report rather than a verdict, and leave confident product guessing out of the loop. That separation between observation and inference is what makes the difference between a useful field-by-field readout and a brittle pattern-matching guess.
Why the "What Browser Am I Using" Question Is Harder Than It Looks
Most people expect a simple answer: open a tool, get the product name and version. The reality is messier. The legacy navigator.userAgent string was originally a short identifier, but over decades it accumulated historical compatibility tokens to help websites detect browsers that no longer existed. A modern Chrome string can include Mozilla, AppleWebKit, Chrome, Safari, and an engine version in one block, even though only one of those is the actual running product. Parsing that string into a confident answer requires a maintained pattern table that maps substrings to versions, and even a good table can be tricked when the string has been reduced, spoofed, embedded in a webview, or modified by an extension.
User-Agent Client Hints were introduced to fix this by exposing structured fields instead of a free-form string. A browser that supports them returns navigator.userAgentData.brands as an ordered list of name and version pairs, a navigator.userAgentData.platform string, and a navigator.userAgentData.mobile boolean. Browsers also insert a deliberate GREASE-style placeholder brand designed to prevent code from assuming a fixed list or order. The result is a richer signal, but it still depends on what the browser chose to expose, which means the right question is "what did my browser report?" rather than "what browser do I have?"
The Fields a Transparent Browser Report Should Show
An honest report surfaces each browser-supplied field separately, with its source and its limit. The What Browser Am I Using tool follows this contract: each value is read locally, labeled clearly, and never re-parsed into a confident product name. The table below summarizes what each field means and where it can mislead.
| Field | Where it comes from | What it honestly means | Common limitation |
|---|---|---|---|
| Reported brands | navigator.userAgentData.brands | Brand and major-version pairs the browser returned, with the GREASE-style placeholder removed | Only present when the client-hint interface is available |
| Platform | client-hint platform or navigator.platform | The general operating system label the browser chose to report | Can be frozen, reduced, legacy-formatted, or chosen for compatibility |
| Mobile hint | navigator.userAgentData.mobile | A boolean the browser sends when it implements client hints | Not a screen-size guess, touch test, or proof of a phone |
| Language | navigator.language | The browser's first language preference | Can differ from content preferences, location, keyboard, or account |
| Cookies enabled | navigator.cookieEnabled | The browser's general reported cookie setting | Does not guarantee every cookie write will succeed |
| Raw user-agent | navigator.userAgent | The complete compatibility string, preserved verbatim | Contains misleading tokens; not authenticated identity |
How to Read the What Browser Am I Using Report
Open the What Browser Am I Using page in your current browser. The fields load locally without any upload. Work through the report in this order to understand what your browser chose to expose.
- Review the reported brand list and note when the page honestly says the browser name is not exposed.
- Compare platform, mobile hint, language, cookie setting, and the raw compatibility user-agent string against what you expect.
- Select Copy browser report and attach it with reproduction steps when troubleshooting, without treating it as authenticated identity.
If the brand list shows a placeholder-like name such as "Not A Brand" or "Not.A/Brand", treat that as a deliberate GREASE entry and ignore it. The remaining entries in their reported order are the brand and version pairs your browser actually chose to advertise. If a brand name looks unfamiliar or duplicated, that is also normal; some browsers ship several entries, and the tool preserves their order rather than reordering them.
When the Page Says "Browser Name Not Exposed"
Some browsers, especially older builds, privacy-hardened forks, or webviews, do not implement User-Agent Client Hints at all, or they return a brand list where every entry is the GREASE-style placeholder. When that happens, the What Browser Am I Using tool refuses to invent a product from the legacy string and prints a clear "Browser name not exposed" message instead. This is a deliberate design choice.
Pattern-matching the legacy navigator.userAgent into a confident product and exact version requires a maintained parser that knows about historical tokens, version formats, mobile and desktop suffixes, and spoofing tricks. Even a good parser can be defeated by a reduced string, an extension, a corporate proxy, or a remote browser service. Reporting "not exposed" is more honest than guessing, and it pushes you toward the next reliable check: open your browser's About or settings screen for the installed product and version.
Using the Copied Report When a Website Breaks
Support teams and bug reports still ask for the raw user-agent string because it is the single field most web servers log. The What Browser Am I Using tool preserves that string verbatim so you can paste it without translation. When you file a report, treat the copied block as opaque compatibility text, not as proof of identity, and pair it with reproduction details.
- The exact failing URL and the time you observed the issue, in your local time zone.
- The steps to reproduce, including any login, redirect, or input that preceded the failure.
- Screenshots or short screen recordings of the broken behavior.
- Your extension state, especially ad blockers, privacy tools, translation overlays, and developer overrides.
- Whether private mode or a different profile changes the behavior, which often points at extensions or stored data.
If the real question is whether a specific Web API is supported, run feature detection in the site's console instead of inferring it from the brand label. A reported brand is a name, not a capability, and security state lives in the browser's own About screen rather than in any string it sends. If you want to see how a parser-based detector would map your string differently, compare with a client-hints-first detector that refuses to lean on legacy token order.
Privacy and Local-Only Behavior
Every field in the report is read locally after the page loads. Nothing is uploaded, fingerprinted into a server record, or persisted by the widget itself. The Copy browser report action only writes to the clipboard after you click it, and no background script harvests your input in the meantime. You can verify this by opening the page with the network tab open and watching for outbound requests; you should see only the static assets that load the page.
The narrow contract is worth restating. The tool shows browser-supplied fields transparently, removes only the known meaningless brand placeholder, preserves raw values, and uses an honest fallback when a product name is not exposed. It does not maintain a large user-agent pattern table, it does not claim to identify the installed application, and it does not decide whether cookies or features actually work for a given site. That limited scope is what makes it safe to leave open while you troubleshoot a layout bug, a login loop, or a download that never starts.
Related reading: Online Scoreboard Explained: Rules, Buttons, and Limits.