Generate synthetic user agent strings for Chrome, Firefox, Safari and Edge across desktop and mobile platforms. Version numbers come from plausible ranges rather than a frozen "current" list, and every string is labelled synthetic β they are for testing parsers, not for impersonation.
Settings
Recent results
Generated locally in your browser β your settings and results never leave this page.
A header shaped by thirty years of workarounds
The user agent string is one of the strangest artefacts on the web. Every mainstream browser begins its string with “Mozilla/5.0” despite most of them having no relationship to Mozilla. Chrome identifies itself as Safari as well as Chrome. Edge identifies as Chrome and Safari before naming itself. Each layer was added to get past a server that was checking for something specific, and none could be removed afterwards without breaking sites that relied on it.
The result is a string that is technically informative and practically unreliable. It is the clearest example on the web of a compatibility measure calcifying into a permanent standard nobody would design on purpose.
Why these are synthetic and stay that way
A generator that promised “current, real user agent strings” would be wrong almost immediately. Browsers now release every few weeks, so a hard-coded version number ages out of date faster than most pages are updated. Worse, a stale list looks authoritative while being wrong, which is more harmful than an honest approximation.
These strings are assembled from realistic components with version numbers drawn from plausible ranges. They have the correct shape, the right structural quirks, and enough variation to exercise a parser. They are not a claim about what browsers people are actually running, and the tool says so on the page and in every export.
Why detection by user agent goes wrong
The reasoning behind user agent detection is that knowing the browser tells you what it supports. In practice the chain breaks at every link. The string is self-reported and trivially altered. Capabilities vary by version, platform and configuration in ways the string does not capture. New browsers appear that no existing lookup table recognises, and a table that fails to match usually falls through to the worst-supported path.
Feature detection asks the question you actually care about: is this capability present. It is accurate today, it stays accurate as browsers change, and it does not need maintaining. The only cases where identifying the browser is genuinely necessary are specific known bugs, and even then the check should be as narrow as possible.
Fingerprinting and the shift to Client Hints
A detailed user agent string contributes a surprising amount to a device fingerprint. Combined with screen size, time zone, installed fonts and a handful of other passively available signals, it can identify a browser across sites without any cookie at all. That is the mechanism behind a good deal of tracking that survives clearing cookies.
Client Hints restructure the exchange. The browser sends a minimal set of fields by default, and a server that genuinely needs more β the exact platform version, say β must ask for it. The request is visible and can be declined. The direction of travel is toward less information volunteered automatically, which is why user agent strings are being progressively reduced rather than extended.
Testing a parser properly
Generated strings cover the normal cases. The interesting failures come from everything else. An empty string, because some clients send none. A string thousands of characters long, because some do that too. A string containing characters a naive regular expression will choke on. A bot or crawler identifier, which follows none of the browser conventions.
A parser that handles the well-formed cases and crashes on a missing header will fail in production, because real traffic contains all of it. Generate the normal values here, then deliberately supply the abnormal ones by hand.
Privacy
Strings are generated in your browser. Your own user agent is not read, and nothing is transmitted, stored or logged.
How to use the Random User Agent Generator
- Choose a browser, or leave it on Any for a mixed set.
- Choose desktop, mobile, or either.
- Set how many strings you need.
- Generate, then copy or export as CSV.
Frequently asked questions
What is a user agent string?
A line of text a browser sends with every request, describing itself and the platform it runs on. Servers historically used it to decide what to send back β a mobile layout, a compatibility shim, or a warning about an unsupported browser.
Why do they all start with "Mozilla/5.0"?
For historical reasons that have long outlived their purpose. Early servers checked for "Mozilla" before sending modern content, so every subsequent browser included it to avoid being served a degraded page. The prefix now means nothing at all, and every mainstream browser carries it.
Are these real user agent strings?
They are synthetic strings assembled from realistic components and plausible version ranges. They are not a record of any real browser population and not a snapshot of current versions β a hard-coded "current" version would be out of date within weeks. They are for testing parsers and layouts.
Can I use these to pretend to be a different browser?
Changing your user agent is a normal part of testing, and browsers include the ability to do it. Using it to bypass access controls, evade rate limits, or violate a service's terms is a different matter. These strings are provided for testing your own software.
Why is user agent detection considered bad practice?
Because the string is self-reported, easily changed, and a poor proxy for what a browser can actually do. Feature detection β testing whether the capability you need exists β is accurate, does not break when a new browser appears, and does not need a lookup table that ages badly.
What is replacing user agent strings?
Client Hints, a mechanism where the browser sends a small set of structured fields and the server can request more detail only if it genuinely needs it. The motivation is privacy: a detailed user agent string is a strong fingerprinting signal, and reducing what is sent by default reduces passive tracking.
How should I test with these?
Feed them through whatever parses user agents in your system and check the results are sensible. Then include the awkward cases: an empty string, a very long one, and something that is not a user agent at all. Parsers frequently assume a shape and fail badly when they do not get it.
