Short answer
The user-agent string is a text header sent by your browser to every website you visit. It identifies your operating system, device model, browser engine, and language settings. This tool parses that string into plain English so you can see exactly what information is being shared without running code on your device.
What a user-agent string actually is
Every time your browser makes a request to a server, it includes an HTTP header called User-Agent. This is a standardized mechanism defined by the W3C that allows servers to serve different content based on the client's capabilities. It is not a secret identifier; it is public information that any developer can inspect via browser developer tools.
Standard structure
Modern user-agent strings typically follow this pattern:
| Component | Description | Example Value |
|---|---|---|
| Browser Token | Identifies the browser engine | Mozilla/5.0 | OS Token | Identifies the operating system | Windows NT 10.0 | Device Model | Specific hardware model (if available) | SM-A546B | Browser Version | Major.minor.build number | Chrome/120.0.0.0 |
| Language | Preferred language codes | en-US |
On mobile devices, the string is significantly longer and includes more specific hardware identifiers. On desktops, it is more generic but still reveals the OS version and browser build.
Why websites request this data
Web developers use user-agent parsing for three primary purposes. Each has practical implications for your privacy and experience.
- Responsive Design: Servers may serve different HTML/CSS based on whether they detect a phone, tablet, or desktop. This ensures the layout fits your screen without relying solely on JavaScript.
- Compatibility Fallbacks: If a browser lacks a specific feature (like WebGL or a modern JS standard), the user-agent helps the server serve a polyfill or simpler alternative.
- Analytics & Fraud Prevention: Developers log user-agents to understand their audience demographics and to flag suspicious bot traffic that might mimic human behavior.
It is important to note that user-agent data is not unique to you. Millions of users with the same browser version on the same OS send the exact same string. It is not a fingerprint in the traditional sense, but it is a coarse identifier. For a deeper look at how identification works, see how websites detect your device.
How to use the User Agent Checker tool
The User Agent Checker on DeviceInfo.in runs entirely in your browser. It does not send your string to a server. Instead, it reads the string from the JavaScript runtime (navigator.userAgent) and parses it locally.
Step-by-step:
- Navigate to the tool. The page will automatically fetch your current string.
- The tool will display the raw string at the top. This is the exact text sent to websites.
- Below, the tool breaks down the string into readable fields: Browser, Version, OS, CPU Architecture, and Language.
- Compare the 'Parsed' view with the 'Raw' view. If the raw string contains tokens the tool didn't label, they are likely non-standard or obsolete fields.
If you are troubleshooting why a site isn't loading correctly, check the Browser Version and OS fields. If a site thinks you are using an old browser, the version number in the string is what they are reading.
Limitations and privacy implications
User-agent strings are unreliable for precise identification. Browser vendors increasingly mask versions or rotate strings to prevent fingerprinting. For example, Safari on iOS always reports 'Chrome' as the engine name for compatibility reasons, even though it is not Chromium-based.
Furthermore, many modern browsers now allow users to customize or randomize the user-agent string via settings or extensions. This makes static parsing difficult. For a comprehensive view of what else your browser reveals, including screen size and GPU info, try the Browser Fingerprint Test. It demonstrates how many data points combine to identify you, while ensuring nothing leaves your device.
Common misconceptions
Misconception 1: "If I change my user-agent, I am anonymous."
This is false. Your IP address, TLS handshake, screen resolution, and font list are all independent signals that contradict a fake user-agent. For more on network-level identification, see Network Information.
Misconception 2: "User-agents are secret."
They are not. Any website you visit can read them. Any developer can view them in DevTools. There is no 'hidden' part to the string that is not visible.
When to check your user agent
You should check your user-agent in these specific scenarios:
| Scenario | Why Check |
|---|---|
| Website looks broken | Check if your browser version is flagged as 'legacy' by the site's parser. |
| Using an extension | Some extensions (like ad blockers) modify the user-agent. Verify it matches your intent. |
| Developing a web app | Test how your app's server-side logic reacts to different device types. See what a user agent is for parsing tips. |
| Privacy Audit | Understand what basic information is shared by default. |
Try it live
You can inspect your current string and see how it is parsed by visiting the User Agent Checker. For a broader view of what your device reveals, try the Device Information tool, which aggregates all available browser APIs in one place.