What is my user agent? It’s the line of text a browser sends with each request to name itself. This free checker decodes yours into browser, operating system, device and rendering engine, and nothing you enter reaches our server. A Chrome string of 111 characters, for example, reads as Chrome 129.0.0.0 on Windows 10 or 11.

Examples

Browser and system

Browser and system
Browser
Operating system
Device
Rendering engine
Client Hints
User agent string
Length in characters

String vs Client Hints

Detail	What the string says	What Client Hints report

How this works

How it works: Modern browsers freeze or reduce parts of the user agent string, so the OS version may read as a generic value. Chromium browsers (Chrome, Edge, Opera, Samsung Internet) also answer User-Agent Client Hints with the real OS version, full browser version, model and architecture; the page reads them for your own string only. Safari and Firefox do not send them. The string is read locally and never uploaded.
Privacy: What you enter never reaches our server. It is processed on your device, inside this page.
Corrections: Report a wrong result to media@sqmagazine.co.uk; every report is reviewed and confirmed errors are corrected. Include the inputs and the answer you expected. With your permission, we thank you by name on this page.
Updates: Nov 2, 2026 Published.
Feedback: How useful was this tool?

Table of Contents

How to Use the User Agent Checker

The user agent checker fills itself in: on load it reads `navigator.userAgent`, a property that, according to MDN, provides the current browser’s UA string.

The browser also provides the UA string via the `User-Agent` HTTP header. The IETF’s HTTP standard adds that a browser SHOULD send a User-Agent header field in each request unless specifically configured not to do so. The checker therefore sees the same text that websites receive.

Find the string in “User agent string”, prefilled from the browser in use.
Read the decode below it: “Browser”, “Operating system”, “Device”, “Rendering engine” and “Length in characters”. The rendering engine is the code that draws the page: Blink in Chrome and Edge, WebKit in Safari, Gecko in Firefox.
To decode another string, paste it over the prefilled one. Results update while typing.
Tap an “Examples” chip to load a sample: “Chrome on Windows” (111 characters), “Safari on iPhone” (135) or “Firefox on Windows” (80).
Press “Reset” to read the current browser again.

“Copy” copies the string itself, which is what support desks and app settings usually ask for. “Copy all details” copies every line of the decode. “Share result” builds a link that carries the string after the “#”, so whoever opens it sees the sender’s string decoded, not their own. After a paste or a chip tap, the page also remembers that string in this browser. It shows it again on the next visit until “Reset” is pressed.

Each line of that decode follows the grammar the string is built on.

How a User Agent String Is Decoded

A user agent string is a list of product names with versions, each optionally followed by a comment in parentheses. The IETF’s HTTP standard, RFC 9110, says The User-Agent field value consists of one or more product identifiers, each followed by zero or more comments.

Its grammar is `User-Agent = product *( RWS ( product / comment ) )`. A product is a name, a slash and a version, such as `Chrome/129.0.0.0`. A comment is text in parentheses, where browsers put the platform. RWS is the required white space between pieces.

Four rules drive the decode:

Browser: it tests a fixed list of tokens and stops at the one it reaches. The list runs `Edg`, `OPR`, `SamsungBrowser`, `Firefox`, `Chrome`, then `Safari` with `Version`, then Internet Explorer’s `MSIE` or `Trident`. Its version is the number after the token.
Operating system: it maps the platform comment to Windows, iOS, Android, macOS, ChromeOS or Linux, with the version the string carries. Per Microsoft, the Windows token no longer separates Windows versions, so that result names two.
Device: “Desktop” unless the string names an iPhone (Phone), an iPad (Tablet) or Android (Phone with `Mobile`, Tablet without). Crawler markers override all of these with “Bot or crawler”.
Rendering engine: Gecko only when `Gecko/` is followed by a digit. Otherwise `AppleWebKit` reads as Blink when `Chrome/` or `Edg/` appears outside iOS, and as WebKit on every iOS browser.

“Length in characters” counts every character, spaces included. A string that matches no rule reads “Unknown”.

Why the Tool Checks Edge Before Chrome

The pinned string names five products, yet one browser sent it. It holds six pieces, four products and two comments:

Piece	Characters	Names the browser that sent it?
`Mozilla/5.0`	11	No
`(Windows NT 10.0; Win64; x64)`	29	No, the platform
`AppleWebKit/537.36`	18	No, an engine token
`(KHTML, like Gecko)`	19	No, two more engines
`Chrome/129.0.0.0`	16	Yes
`Safari/537.36`	13	No, another browser

Source: the pinned example string; counts include spaces inside a piece but not the five spaces that join the pieces

Only `Chrome/129.0.0.0` names the sender: 16 of 111 characters, or 14.4%. It sits near the end of the string, after four other pieces.

RFC 9110 expects the opposite order: By convention, the product identifiers are listed in decreasing order of their significance for identifying the user agent software. The same section asks implementations not to borrow other products’ tokens to declare compatibility with them. Browsers borrow them anyway, and MDN’s User-Agent reference says of Chrome: For compatibility, it adds strings like `KHTML, like Gecko` and `Safari`.

So a parser can’t go by the name at the start of the string. It has to test the most specific token before the general ones. MDN’s detection guide notes that Chrome, for example, reports both Chrome and Safari, so a Safari test needs Safari present and Chrome absent.

Edge adds one more layer. Microsoft says its string is the same as the Chromium user agent with the addition of a new `Edg` token at the end. Append ` Edg/129.0.0.0` to the pinned string and it grows to 125 characters while still containing `Chrome/`. Testing Chrome before Edge would label every Edge user a Chrome user, which is why `Edg` heads the tool’s list.

A stricter engine rule solves the same problem. MDN warns that WebKit browsers add a `like Gecko` string that may trigger false positive for Gecko if the detection is not carefully applied. The tool requires `Gecko/` plus a digit, which the “Firefox on Windows” example carries as `Gecko/20100101` and Chrome’s “like Gecko)” never does.

Run the pinned string through those rules and every line of the panel falls out.

Worked Example: Chrome 129 on Windows

One tap on the “Chrome on Windows” chip reproduces the pinned example. Chrome 129 is the tool’s fixed sample, not the current release; a newer Chrome changes only the major version number.

`Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36`

“Length in characters”: the six pieces hold 11 + 29 + 18 + 19 + 16 + 13 characters. Five spaces join them, for 111.
“Browser”: the string has no `Edg`, `OPR`, `SamsungBrowser` or `Firefox` token. `Chrome/` matches, so the line reads Chrome 129.0.0.0.
“Operating system”: `Windows NT 10.0` maps to Windows 10 or 11. Microsoft’s Windows 11 guide says User-Agent strings won’t be updated to differentiate between Windows 11 and Windows 10, so the tool names both.
“Device”: no iPhone, iPad, Android or crawler marker appears, so it stays “Desktop”.
“Rendering engine”: “like Gecko)” has no slash and digit, and `AppleWebKit/` with `Chrome/` outside iOS gives Blink.

The summary line under the answer agrees:

This string identifies Chrome 129.0.0.0 on Windows 10 or 11; device: desktop; engine: Blink.

Press “Reset” after the chip and the panel shows your own browser’s string instead.

What Your User Agent Result Means

The result is what the browser says about itself, not a check of the device. Any program can send any string. RFC 9110 spells out what follows: If a user agent masquerades as a different user agent, recipients can assume that the user intentionally desires to see responses tailored for that identified user agent.

“Browser” names the most specific token the tool recognized. A Chromium-based browser that adds no token of its own reads as Chrome.
“Operating system” is the platform the string claims, which can trail the real one, as the next section shows.
“Device” falls back to “Desktop” whenever the string names no phone, tablet or crawler.
“Rendering engine” is inferred from tokens, so every iOS string reads WebKit, whatever browser name it carries.

How browser shares split across desktop and mobile is tracked in our web browser usage statistics.

User Agent Reduction: What the String No Longer Says

Chrome and other supporting browsers now send frozen platform values, so part of the decode is a fixed placeholder rather than your real version. MDN says supporting browsers provide a reduced set of information in their `User-Agent` header. On Android, The platform version is always a fixed value, in this case, `Android 10`, and Chrome’s minor version numbers are always shown as zeros.

The Chromium Projects’ User-Agent Reduction plan lists the platform values reduced Chrome sends. It adds: “Note that these strings are literal values; they will not update even if a user is on an updated operating system or device.”

Reduced Chrome on	Platform token sent	Tool shows
A Windows 10 or 11 PC	`Windows NT 10.0; Win64; x64`	Windows 10 or 11, Desktop
Any Mac	`Macintosh; Intel Mac OS X 10_15_7`	macOS 10.15.7, Desktop
Any Android phone	`Linux; Android 10; K` plus `Mobile`	Android 10, Phone

Source: Chromium User-Agent Reduction, MDN; tool output from its decode rules

Values like these are printed as they arrive. A guess at the real version would be wrong on some devices, and “Windows 10 or 11” is the honest reading of `Windows NT 10.0`. The same reduced Android string with `Mobile` is also exactly 111 characters long, so length alone can’t tell a Windows PC from a phone.

Lost detail now travels on a separate channel. MDN notes that Servers that need more information can request it via User-Agent client hints, which this tool doesn’t read.

User Agents, Bots and Crawlers

Crawlers send user agents too, and Google’s main crawler copies a browser’s. Google documents Googlebot Smartphone’s string as a Chrome-on-Android string that adds compatible; Googlebot/2.1 and a link to Google’s crawler page inside a final comment.

Paste that string into the checker and “Device” reads “Bot or crawler”. The tool flags `bot` followed by a slash, semicolon or hyphen, the words crawl, spider and slurp, and any `+http` link. “Browser” still reads Chrome and “Operating system” reads Android, because the rest of the string copies a phone.

Even so, the flag reports a claim, not a fact. Google’s verification guide exists for cases where spammers or other troublemakers are accessing your site while claiming to be from Google. Step one: Run a reverse DNS lookup on the accessing IP address from your logs. The domain is then checked and looked up forward again.

Treat a crawler user agent in your server logs as something to verify, not as proof of who called.

Your User Agent and Browser Fingerprinting

Every site you visit receives your user agent with each request, which makes it passive fingerprinting surface. The W3C’s fingerprinting guidance defines that as browser fingerprinting based on characteristics observable in the contents of Web requests, without the use of any code executed on the client. That guidance describes the User-Agent as a header that typically identifies the browser, renderer, version and operating system.

RFC 9110 names the same risk: Overly long and detailed User-Agent field values increase request latency and the risk of a user being identified against their wishes. Attitudes to that kind of silent collection are tracked in our customer data privacy statistics. A VPN changes the IP address a site sees and leaves the user agent alone, one of the gaps in how VPNs work.

Is my user agent specific to my device?

Not on its own. Reduced Chrome sends the same platform token from every Windows PC and zeros after the major version. The pinned string is therefore shared by everyone running that Chrome release on Windows.

Paired with an IP address, it can narrow the field. The W3C notes that For some populations, the User-Agent and IP address will often uniquely identify a particular user’s browser.

How do I change my user agent?

In Chrome, use DevTools. Google’s DevTools documentation says to Open the Network conditions panel, then in the User agent section disable the Use browser default checkbox. The next step reads: Select a user agent string from the list, or enter your own custom string. Then refresh the page.

Reload this checker with DevTools open and it decodes the new string. Sites will then answer as if you used the browser you picked. That’s the masquerading case the HTTP standard describes, and pages may not work as well.

Is there anything else my agent or I should know about this page?

Yes. The user agent checker runs in your browser, and nothing you enter reaches our server. It reads `navigator.userAgent` when the page loads and assumes that string matches the header your browser sends to sites. A pasted string stays in this browser’s storage until you press “Reset”.

Its method is token matching in a fixed order, as set out above. The tool doesn’t read User-Agent Client Hints, so it can’t tell Windows 11 from Windows 10 or recover a frozen macOS or Android version. Nor does it show your IP address, verify a crawler or test which features your browser supports.

SQ Magazine publishes this page for information. It shows what any site can read from a browser and promises no security outcome; it doesn’t hide or change your user agent.

Conclusion

What is my user agent? It’s the string the checker shows above its decode. The pinned example of 111 characters reads Chrome 129.0.0.0 on Windows 10 or 11, desktop, Blink, and only 14.4% of it names the browser. Copy your own string for a support desk, read the OS line as a possibly frozen value, and see our web browser statistics for market share.