# Why every Mac's Chrome says Mac OS X 10_15_7 > Chrome froze the macOS version in its User-Agent, so every Mac claims 10.15.7. The real one is in Sec-CH-UA-Platform-Version, a hint sites must ask for. Source: https://mosaicbrowser.com/blog/mac-os-x-10-15-7 ## Why every Mac's Chrome says Mac OS X 10_15_7 Chrome froze the macOS version in its User-Agent, so every Mac claims 10.15.7. The real one is in Sec-CH-UA-Platform-Version, a hint sites must ask for. ![10_15_7: Every Mac, one frozen version, beside a screenshot: a profile fingerprint in Mosaic: GPU, screen, fonts, timezone and language matched to the exit](https://mosaicbrowser.com/covers/mac-os-x-10-15-7.webp) Chrome on a Mac says `Mac OS X 10_15_7` because that number is frozen. Every Mac running Chrome sends `Macintosh; Intel Mac OS X 10_15_7` in its User-Agent, whether it runs Catalina or the latest macOS, on Intel or Apple silicon. The real version moved to a client hint, `Sec-CH-UA-Platform-Version`, which a site has to ask for. ## Why the number stopped at 10_15_7 For almost twenty years the macOS version in a User-Agent began with 10. Mac OS X 10.4, 10.9, 10.15: the first number never changed, and a lot of code on the web was written as if it never would. When macOS 11 arrived, browsers that reported `11_0` found sites that read the version wrong or refused to work, because their parsers looked for a `10_` and found nothing. Safari and Firefox capped the number first, and Chromium followed. The cap also suited a project Chrome was already running, User-Agent Reduction, which trims what the string gives away to every server on every request. A frozen OS version is one fewer thing to tell a site that never asked. So the browsers on a Mac now write: | Browser | macOS part of the User-Agent | | --- | --- | | Chrome | `Macintosh; Intel Mac OS X 10_15_7` | | Safari | `Macintosh; Intel Mac OS X 10_15_7` | | Firefox | `Macintosh; Intel Mac OS X 10.15` | `Intel` is part of the freeze too. An M-series Mac says Intel in the string and `arm` in the `Sec-CH-UA-Arch` hint, and that pairing is normal ([the arm and x86 record we once had wrong](https://mosaicbrowser.com/blog/ua-architecture-x86-arm) is that story from our side). Mosaic is a desktop app Email yourself the link and open it on your computer. [How it works: Machines that exist](https://mosaicbrowser.com/features/real-fingerprints) ## Where the real macOS version lives Chrome sends the low-entropy hint `Sec-CH-UA-Platform: "macOS"` with ordinary requests. The version is a high-entropy hint, so it only arrives when a site asks for it: an `Accept-CH: Sec-CH-UA-Platform-Version` response header, after which Chrome includes it on later requests to that origin, or one call in JavaScript: ``` await navigator.userAgentData.getHighEntropyValues(['platformVersion']) // { platform: "macOS", platformVersion: "26.6.2", ... } ``` That `26.6.2` is what a stock Chrome reported on the Mac we measured on. The User-Agent beside it still said `10_15_7`. Both are true at once: the string says "a Mac", the hint says which one. Safari and Firefox do not implement `userAgentData`, so on those browsers the version is not available from the string or from a hint. The full list of hints a page can request, and which ones also travel as headers, is in [getHighEntropyValues explained](https://mosaicbrowser.com/blog/gethighentropyvalues-explained). ## A newer macOS in the User-Agent is the tell The useful consequence for anyone building or checking a browser profile runs the other way from intuition. A profile that writes `Mac OS X 15_1` or `Mac OS X 26_0` into its User-Agent looks more up to date and is less like any real Chrome. No Chrome has sent those strings on any Mac, so the claim marks the browser as one whose User-Agent was typed by somebody. There is a second cost, and it is worse because it is invisible from the string. In Chromium, passing `--user-agent` on the command line empties every high-entropy hint. We measured it on a stock Chrome with that switch as the only flag and a string byte-identical to Chrome's own: ``` without --user-agent architecture "arm" platformVersion "26.6.2" with --user-agent architecture "" platformVersion "" ``` Chromium will not vouch for values it can no longer derive from a string it did not choose. So a hand-written macOS version usually arrives with an empty `platformVersion`, and a real Chrome on a Mac never answers that way. The DevTools route has the same trap: an override sent without `userAgentMetadata` clears the hints for the page, which we measured in [setUserAgentOverride without metadata](https://mosaicbrowser.com/blog/setuseragentoverride-clears-hints). The hint has its own version of the mistake. A profile that claims an old macOS in `platformVersion` while running on a newer one disagrees with itself, because a service worker can read `platformVersion` too, and that realm is hard to reach from page-level JavaScript. ## What Mosaic writes on a Mac Every macOS profile Mosaic draws gets the same platform token Chrome uses, `Macintosh; Intel Mac OS X 10_15_7`. The generator has one line for it, and the comment above it says why: Chrome freezes the reported macOS version regardless of the real one. The version itself comes from the Mac underneath. The generator once drew `platformVersion` from a table of macOS releases, and the table topped out at 15.6.1 while the machine ran 26.6.2. Every profile claimed an older system than the one it was on, and a service worker in the same browser could report the newer one. Now the generator reads the host's own version and stores that, so the page, the worker and the header all give one answer. Mosaic also leaves out `--user-agent` when a profile's string equals the engine's own, so the hints stay filled in. How the rest of the hardware is drawn from real machines is on [real fingerprints](https://mosaicbrowser.com/features/real-fingerprints). ## Checking your own browser Open DevTools on any https page and run the line above. On a real Mac in Chrome you should see `platform: "macOS"` and a version that matches About This Mac, beside a User-Agent ending its platform part in `10_15_7`. If a profile you are testing shows a different number in the string, or an empty `platformVersion`, it has stopped looking like the browser it claims to be. ## Questions ### Does Mac OS X 10_15_7 in my User-Agent mean my Mac is out of date? No. Chrome writes 10_15_7 on every Mac whatever version it runs. The number stopped moving on purpose and says nothing about your system. To see the real version, read Sec-CH-UA-Platform-Version or the platformVersion client hint. ### Why does it say Intel on an Apple silicon Mac? The same freeze. The platform part of the string reads Macintosh; Intel Mac OS X 10_15_7 on every Mac. The processor is reported in the Sec-CH-UA-Arch hint, which says arm on Apple silicon. ### How does a website find the real macOS version? It asks for the Sec-CH-UA-Platform-Version client hint with an Accept-CH response header, or calls navigator.userAgentData.getHighEntropyValues(['platformVersion']) in JavaScript. Chrome answers with the real version, such as 26.6.2. ### Should a browser profile put a newer macOS version in its User-Agent? No. No Chrome sends anything but 10_15_7 there, so a newer number marks the browser as one whose string was written by hand. The version belongs in the client hint, and it should be one a real Mac could be running. ## Related [Our profiles said x86 and the browser said arm](https://mosaicbrowser.com/blog/ua-architecture-x86-arm): Chrome on an Apple silicon Mac sends Sec-CH-UA-Arch "arm". Our profile records said "x86", read by nothing, so we fixed the record, not the browser. [getHighEntropyValues: what a page can ask for and what it gets](https://mosaicbrowser.com/blog/gethighentropyvalues-explained): getHighEntropyValues hands a page architecture, bitness, model and full versions on request, and each answer must match the headers Chrome sends. [setUserAgentOverride without metadata wipes your client hints](https://mosaicbrowser.com/blog/setuseragentoverride-clears-hints): Without userAgentMetadata, setUserAgentOverride left our page with empty brands while a worker reported both. We set the User-Agent at launch instead. [Machines that exist: fingerprints drawn from real hardware](https://mosaicbrowser.com/features/real-fingerprints): Mosaic draws each profile's GPU, screen, CPU, memory and fonts from one real device, so the parts of a fingerprint agree with each other and with the host. [Why the User-Agent says Windows 10 on Windows 11](https://mosaicbrowser.com/blog/windows-11-user-agent-windows-10): Windows 11 and 10 both send Windows NT 10.0 in the User-Agent. Only the platformVersion client hint, 13 or higher, says Windows 11. [Why Chrome's User-Agent says 0.0.0](https://mosaicbrowser.com/blog/chrome-user-agent-0-0-0): Chrome zeroes everything after the major, so the User-Agent says 0.0.0 and the build moves to Sec-CH-UA-Full-Version-List. A real build in the UA is a tell. [Privacy Sandbox is retired, and its APIs are a version tell](https://mosaicbrowser.com/blog/privacy-sandbox-apis-removed): Chrome is removing Topics and Protected Audience release by release, so whether runAdAuction exists tells a page which Chrome you really are. [Accept-CH and Critical-CH: how a server asks for more](https://mosaicbrowser.com/blog/accept-ch-critical-ch): Accept-CH asks Chrome for more client hints on the next request; Critical-CH makes it retry the first. A server sees both requests and can compare them. ## Mosaic, on your own computer The browser this blog is about: its own Chromium, fingerprints from real machines and a proxy exit per profile. Free holds 3 profiles. Pro is $49 a month for any number. Mosaic is a desktop app Email yourself the link and open it on your computer.