User Agent Generator
Current user agents for Chrome, Edge, Firefox and Safari on every major platform, each with the Client Hints a real build sends and checked for contradictions before you copy it. Free, no signup, runs in this tab.
- Runs entirely in your browser
- Version table dated September 2026
- No signup
Which browser, on what?
Only combinations that ship are offered. Version table as of September 2026.
Generated identities
Each string with the hints a real build sends beside it. Regenerate for a fresh spread.
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36
10 identities, each with a full Client Hints set. Every set passes the contradiction check the user-agent parser runs.
Now give every account its own device.
A clean browser is still one browser. Sendwin runs each profile in isolation with its own fingerprint, cookies and proxy, so the accounts you work on never look like they came from the same machine.
- Isolated profiles, each with its own fingerprint and cookies
- A proxy per profile, with the timezone bound to the proxy country
- Windows, macOS and Linux — plus cloud sessions when you need them
The free plan includes 10 minutes of cloud browsing a day.
A string, and everything that has to agree with it
A user agent is the easiest thing about a browser to change and the hardest to change convincingly. The string itself takes one line in any automation framework. What a server actually checks is whether the rest of the request agrees with it: a Chrome string arrives with a sec-ch-ua brand list whose placeholder entry is derived from the major version, a platform hint that matches the OS token, a full-version list whose build numbers are plausible for that release, and an architecture the platform can have. Lists of user agents copied from the web fail those checks constantly, because they carry a string and nothing else.
This generator builds the string and the hint set together. You choose the browser, the platform, the OS release and how the version should be picked — the current stable, or a spread across recent releases the way an installed base actually looks — and each result is run back through the same comparison our user-agent parser performs. If any field disagreed with the string you would see it here, before a target site does. Firefox and Safari produce strings without hints, because those browsers send none, and the output says so rather than inventing a set.
Why the string is the easy half
Chromium reduced its user agent years ago: the Windows token is frozen at 10.0, the macOS one at 10_15_7, the Android one at 10 with the device model replaced by a K, and the minor version at .0.0.0. All the detail moved into Client Hints, sent as headers and readable as navigator.userAgentData. That is the part a hand-written identity usually gets wrong. The GREASE brand — the deliberately odd entry in the brand list — is not random; it is computed from the major version, and a list with the wrong one was not produced by a browser. The full-version list carries real build numbers, the platform version carries the real OS release, and every one of those has to fit the string beside it.
What the version table is, and what it is not
The browser majors offered here are static data with a date on them. A static page cannot ask Google what today's Chrome is, so the table is checked when the site is rebuilt and the date is shown on the page; if it has drifted, pick a major by hand. The full build numbers in the hints are representative — plausible for that release, not copied from a release note — because a hint that carries a build number is what a real browser sends, and an empty one is what a hand-made set sends. Treat the output as a coherent identity, not as a citation.
Formats: headers, JSON, Playwright, Puppeteer
Strings only is the plain list. With Client Hints adds the header block under each string, ready to paste into a request tool. JSON carries everything, including the structured hint set. The Playwright output is a list of context options with the low-entropy hints as extra headers, since Playwright's userAgent option sets the string alone. The Puppeteer output pairs each string with the userAgentMetadata object that page.setUserAgent() accepts, which is the one way in Puppeteer to set the string and the hints from a single call so they cannot drift apart.
How each identity is built
- 1
Choose a platform and browser
Only combinations that exist are offered: Safari on Apple platforms, Chromium browsers everywhere, and on iOS every browser is WebKit underneath.
- 2
Build the string and its hints
The string follows the reduced format that release actually sends. The hints are generated from it with the real GREASE algorithm, then filled with the OS release, build number, architecture and model.
- 3
Run the contradiction check
Each pair goes through the same field-by-field comparison as the user-agent parser. The status line under the output says whether every set passed.
Other free checks
A generated identity is a claim. These read what a browser cannot simply rewrite.
- User Agent ParserDecode a user agent and check it against its Client HintsRun the check
- HTTP Headers TestSee the headers your browser sends, and whether they agree with JavaScriptRun the check
- Bot Detection TestSee the automation tells a bot filter reads firstRun the check
- Browser Fingerprint CheckerSee every signal your browser hands to websitesRun the check
User agent generator FAQ
What the strings are, why some come without hints, how current the table is, and what a string cannot do for you.
Testing how a site behaves for a browser you do not have, feeding an automation script identities that look like installed browsers rather than a default headless string, and building a profile by hand when a tool does not do it for you. In every case the useful output is a string plus the hints that belong with it, which is what this page produces.
They are the strings those browsers send, in the reduced format each one uses, with current major versions. The hints are the set a real build would publish alongside, generated with Chromium's own brand algorithm. The build numbers inside the full-version list are representative rather than copied from release notes, which is stated on the page so nobody cites them.
Because neither browser sends them. Client Hints are a Chromium feature; Firefox and Safari identify themselves through the user agent alone, and every browser on iOS is WebKit and does the same. A request carrying sec-ch-ua headers while claiming Firefox is the kind of contradiction this page exists to prevent, so the generator produces none for those browsers.
That is the reduced user agent every current Chromium build on Android sends: the release is frozen at 10 and the model at the literal K. The real Android version and the real device model travel in the platform-version and model hints, which is where this generator puts them.
The month it was last checked is printed on the page. Browsers ship a new major every four weeks or so, so a table can be a release behind between site rebuilds; if it is, choose a major by hand rather than trusting the default. Everything else about the string and the hints is derived from the number you pick.
No, and it can make things worse. A user agent that disagrees with the fonts, the GPU, the screen, the time zone or the Client Hints beside it is a contradiction, and contradictions are what get accounts flagged. The string only helps when everything around it was chosen to match, which is exactly the job this page cannot do for the rest of the browser.
Each profile's user agent is generated together with its Client Hints, platform, fonts, GPU and screen, so no field has to be explained away against another — and the version follows the engine, so it never falls behind the real browser. Free for 30 days on Windows, macOS and Linux.
Still have questions? Talk to us →
What a coherent identity is, and is not
The output is a coherent identity in the sense that every field agrees with every other field, verified by the same comparison our parser runs. It says nothing about whether that identity matches the machine, the fonts, the screen or the connection it is used with, and a string that fits none of those is worse than none at all. The version table is static and dated; check the date.
Generated identities, with the rest of the browser to match.
Sendwin generates each profile's user agent together with its Client Hints, fonts, GPU and screen, and keeps the version current with the engine. Free for 30 days on Windows, macOS and Linux.
30-day free trial · $0 today · cancel anytime — your profiles stay on your machine