DEV Community

Nullprint
Nullprint

Posted on Fully Autonomous

Mozilla measured 25M Firefox users: a handful of browser signals do most of the fingerprinting

Browser fingerprinting test sites love long lists: canvas, audio, fonts, plugins, sensors, dozens of WebGL parameters. The intuitive takeaway is that you're unique because of everything.

Mozilla just published data that says otherwise. Their paper, Large-Scale Measurement and Real-World Mitigation of Web Browser Fingerprinting in the Wild (accepted at ACM CCS 2026), is based on telemetry from almost 25 million Firefox release users. The team re-implemented the measurements collected by three commercial fingerprinting scripts, Fingerprint Pro, Signifyd and Akamai, and checked how well each one could tell those users apart.

Here's what stood out to me, plus a snippet you can run to see the same signals in your own browser.

1. A few metrics make most people unique

Of all the users Fingerprint Pro saw as unique, 80% were already unique after just 8 metrics, even though the script collects over 50. Signifyd collects more than 80 metrics, yet sees fewer users as unique, and 80% of those are pinned down after 9.

So uniqueness isn't caused by one magic value, and it isn't caused by 30 values piling up either. It's a small set of high-impact signals and the way they combine.

2. Protecting those few signals cuts uniqueness a lot

Mozilla then applied protections one at a time and re-measured. This is their figure (from the project page):

Percentage of unique users with successive protections applied, Fingerprint Pro 75.7% to 46.8%, Signifyd 60.9% to 38.5%, Akamai 18.2% to 9.0%
Source: Ritter et al., fingerprinting.study (Mozilla, University of Toronto, UC San Diego)

With all steps applied, the share of users Fingerprint Pro could single out dropped from 75.7% to 46.8%. Signifyd went from 60.9% to 38.5%, Akamai from 18.2% to 9.0%.

The steps on the x-axis are mundane: CPU core count, WebGL renderer string, browser patch version, installed fonts, math function results, available screen resolution. Two of them do a lot of the work in this chart. Generalizing the WebGL renderer alone takes roughly 8 points off Fingerprint Pro and about 12 off Signifyd; the font protections take off about another 9 for Fingerprint Pro.

Concrete examples from Mozilla's blog post: Firefox can report the processor count as either 4 or 8 instead of the exact number, and limits what the screen APIs reveal about the size and position of your taskbar or dock.

3. A single percentage hides the real story

The authors are blunt about this: be suspicious of any one number for "how many users are unique". Your OS is always visible to a site (lying about it breaks keyboard shortcuts and download pages), so they split the population by OS, and each one behaves differently.

The clearest example: clamping the available screen resolution takes 25.3 points off uniqueness on macOS, but only 0 to 3 points on the other three platforms. Averaged across everyone, it looks like a 3.5-point tweak.

4. Entropy is the wrong yardstick; cohort size matters

It's common to rank fingerprinting signals by Shannon entropy. The paper shows high entropy doesn't reliably predict how much a signal helps a fingerprinter.

They also look at the people who aren't unique. One million users sharing a fingerprint is very different from 500,000 pairs. Using the Simpson index, they found two protections that each removed about 2.1 points of uniqueness, but one improved the cohort score by 56% and the other by only 13%.

5. Standardize and randomize, and don't break sites

Making everyone report the same value helps, but some users will always stand out, especially on small sites. Randomization is strong when it works, but it can be detected. Their conclusion: neither carries privacy alone.

And protections have to keep the web working. Users who flip a strict setting and hit a broken site days later never connect the two; they just decide the browser is broken.

See the signals in your own browser

Paste this into DevTools on any page. It reads a few of the values discussed above:

const gl = document.createElement('canvas').getContext('webgl');
const dbg = gl && gl.getExtension('WEBGL_debug_renderer_info');

console.table({
  cpuCores: navigator.hardwareConcurrency,
  screen: `${screen.width}x${screen.height}`,
  // smaller than "screen" by the size of your taskbar or dock
  availableScreen: `${screen.availWidth}x${screen.availHeight}`,
  webglRenderer: dbg
    ? gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL)
    : gl && gl.getParameter(gl.RENDERER),
  timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
  language: navigator.language,
});
Enter fullscreen mode Exit fullscreen mode

Run it in Chrome and in a recent Firefox and compare the CPU count and renderer lines. For the full picture, Mozilla's browser test compares each of your values against the ~25 million measured browsers, entirely locally.

Notice the last two rows. Mozilla deliberately keeps time zone and language accurate because websites need them. That means they're always in the fingerprint, so they had better agree with everything else, including the IP address the site sees.

Why this matters if you run many browser profiles

If you manage several browser profiles (QA environments, multiple storefronts, a team sharing accounts), this paper is a useful reality check:

  • Focus on the high-impact values. CPU count, GPU renderer, screen and available screen, fonts, OS. These carry most of the identifying power.
  • Keep them plausible together. A value that matches no real machine, like a Mac screen with a Windows taskbar gap or a GPU that doesn't ship with that OS, is a fingerprint of its own.
  • Make them consistent with the network. Time zone and language are never hidden, so they should match the exit IP.
  • Keep them stable. Values that change on every launch are easy to spot.

Mozilla also notes they deliberately didn't publish everything their data could support, to avoid helping build better fingerprinters. The paper, the full appendix data and the analysis code are all linked from fingerprinting.study, and the Mozilla Security Blog post is a good shorter read.


Disclosure: I work on Nullprint, an AI antidetect browser for Windows and macOS where each profile keeps a fixed, consistent fingerprint and AI agents can operate profiles through MCP. None of the findings above depend on it. This post was written with AI assistance.

Top comments (0)