Two physically distinct devices can produce the same browser fingerprint. That is not a bug: it is a consequence of limited entropy, large populations, and homogeneous device configurations. This post explains collisions from first principles and how probabilistic scoring reduces false matches.
The uncomfortable truth: fingerprints can collide
Browser fingerprinting is often described as though each device has a unique signature, as reliably individual as a physical fingerprint. The analogy flatters the technology. A real fingerprint has a theoretical uniqueness grounded in the combinatorial explosion of ridge detail across millions of skin cells. A browser fingerprint has whatever entropy the browser's API surface happens to expose, divided among an enormous global population of devices.
When the entropy budget is smaller than the population demands, two different devices will inevitably produce the same fingerprint. This is called a collision, and it is not an edge case. For any system that relies on fingerprints for identity decisions, understanding when and why collisions happen is as important as understanding when they do not.
Bits of entropy: the measuring stick for uniqueness
Information theory gives us a clean way to reason about fingerprint uniqueness. A signal that can take N equally likely values carries log2(N) bits of entropy. A binary signal (present/absent) contributes one bit. A signal with 1,024 possible values contributes ten bits. The total entropy of a fingerprint is roughly the sum of the independent bits across all the signals that compose it.
The EFF's Panopticlick study, published in 2010 and extended in subsequent work, was one of the first large-scale measurements of this for browser fingerprints. Its headline finding was that the average browser fingerprint carried about 18.1 bits of identifying information from the set of signals it examined. Eighteen bits can distinguish roughly 280,000 individuals from one another.
That sounds like a lot until you consider scale. A site with millions of monthly visitors, or a fraud-detection network operating across many properties, is operating in a population where 18 bits is nowhere near enough. At a population of ten million, 18 bits of entropy means you expect on average 38 collisions per fingerprint value. At a hundred million, that climbs to 381. The fingerprint is not wrong; it is just not doing enough combinatorial work for the population size.
The amiunique.org project, which collected browser fingerprints from hundreds of thousands of volunteers, found that uniqueness rates varied sharply by device type. Desktop browsers in non-default configurations achieved high uniqueness rates, often above 90 percent in the study population. Mobile browsers, especially on popular handsets running stock configurations, were far less unique, precisely because so many users share identical hardware, OS version, and browser build. The collision rate is not a property of fingerprinting in the abstract: it is a property of fingerprinting a specific population.
Why common configurations collide
Collisions cluster around homogeneity. The same-fingerprint problem is not uniformly distributed across the population: it concentrates at the modes of the distribution, the most common device-and-configuration combinations.
Fresh OS installations are a textbook example. A device that has just been reinstalled, or factory-reset, has default fonts, default browser, default settings, no extensions, and the same driver versions as every other machine that received the same build on the same day. Before the user personalises it, it is nearly indistinguishable from tens of thousands of identical machines. The entropy from those personalisation signals is simply absent.
Corporate device fleets push this further. An enterprise with 10,000 laptops deployed from the same image, managed by the same MDM policy, with the same approved software, running the same browser version locked by IT, has deliberately collapsed entropy across the entire fleet. From a fingerprinting perspective, these devices are functionally identical on first visit. Any identity system that tries to distinguish them from a fingerprint alone will fail, because there is no information to distinguish them: they are genuinely the same fingerprint.
Popular phone models create the same effect at consumer scale. The best-selling Android handsets ship tens of millions of units with identical hardware profiles. A screen geometry, GPU model, and OS build combination shared by fifteen million phones produces fifteen million identical or near-identical fingerprints. Even with the browser's user-agent string included, the entropy might only reach a few thousand distinguishable values spread across those millions of devices.
Privacy-hardening compounds it in a different direction. Browsers like Tor Browser deliberately normalise their fingerprint surface to make every Tor user look identical to every other. This is the intended behaviour: the threat model assumes the population of Tor users is a meaningful anonymity set. But it means a Tor fingerprint is, by design, maximally colliding.
Scenarios and their collision risk
| Scenario | Why collisions happen | Relative collision risk |
|---|---|---|
| Fresh OS / factory reset | No personalisation signals yet; every default is the same | High |
| Corporate managed fleet | IT policy enforces uniform software stack | Very high |
| Popular phone models (stock) | Shared hardware, OS, and browser version across millions of units | High |
| Tor Browser users | Fingerprint normalised by design to the Tor user population | Very high (intentional) |
| Custom desktop with extensions | Personalisation adds entropy; extensions shift the fingerprint | Low |
| Power user with rare fonts/GPU | Uncommon configuration; high individual entropy | Very low |
The birthday problem: why scale makes collisions inevitable
The birthday paradox from probability theory makes the scale problem precise. If you sample uniformly from a space of M possible fingerprint values, you expect the first collision after roughly sqrt(M) samples. A fingerprint space with 280,000 distinct values (18 bits) produces its first expected collision after only about 530 devices. By 1,000 devices you have a better-than-even chance of at least one collision.
This is why uniqueness rates reported by studies like Panopticlick are population-dependent. In a study of 150,000 volunteers who chose to participate (and are therefore somewhat biased toward more technical, more customised devices), the uniqueness rate looks impressive. In a deployment across a mass-market consumer product with tens of millions of users on common phones, the collision rate in the most-common configuration bins can be substantial.
The takeaway is not that fingerprinting is unreliable. It is that uniqueness is a function of entropy relative to population size, not an absolute property of the technique. A fingerprint that works well for 100,000 users may produce frequent collisions for 10 million.
How multi-signal fusion reduces false matches
If a single-hash fingerprint cannot guarantee uniqueness at scale, the engineering response is not to give up on fingerprinting: it is to change what the system is being asked to do.
Multi-signal fusion treats the fingerprint as a vector of individual signal values rather than a single opaque hash. Instead of asking 'are these two hashes equal?', the system asks 'across all the individual signals, how similar are these two fingerprint collections, and where do they agree and disagree?'. This reframing has two consequences.
First, two fingerprints that produce the same hash by collision may still differ on signals that were not included in the hash, signals that carry entropy but whose values do not change the hash output. A similarity-based comparison can surface that difference even when the aggregate hash is identical.
Second, expressing the result as a probability or a confidence score rather than a binary match makes the uncertainty explicit. A score of 0.97 means strong evidence of the same device. A score of 0.61 means moderate evidence, below the threshold for high-confidence decisions. This is the core of probabilistic similarity scoring: instead of a yes/no answer, you get a graded measure of identity evidence that you can interpret relative to your use case.
See the glossary entries on [deterministic vs probabilistic matching](/glossary/deterministic-vs-probabilistic-matching) and [fuzzy fingerprint matching](/glossary/fuzzy-fingerprint-matching) for more on how these two modes differ and when each is appropriate.
Layering signals across different categories compounds the entropy effect. A fingerprint that draws on GPU characteristics, font metrics, display geometry, and timing behaviour simultaneously requires a would-be collision to match on every dimension at once, which is exponentially less likely than matching on any one dimension. Even in a homogeneous fleet, individual signals within each category may carry small residual differences that a vector-based comparison can exploit even when the top-level hash matches.
What good system design looks like
The practical response to the collision problem has several components.
Measure your collision rate in your real population, not in a research study. Segment by device type: you may find that desktop browsers in your user base are highly unique while mobile traffic clusters into a handful of common profiles.
Use fingerprints as a strong signal rather than the only signal. Combining a fingerprint with a behavioural pattern, a session cookie, a network signal, or a login history gives you multiple independent pieces of evidence. A collision on fingerprint alone does not mean a collision on all of them.
Design for probabilistic rather than deterministic identity. A fingerprint that returns a 94-percent confidence score is useful for fraud scoring, risk tiering, and anomaly detection without needing to be a guaranteed unique identifier. The expectation that a fingerprint is either identical or irrelevant is a legacy of cookie-era thinking applied to the wrong technology.
Understand the homogeneity of your adversary. A credential-stuffing attack using automated browsers running on cloud VMs may produce highly similar fingerprints that look like a fleet, precisely because they are a fleet. Recognising the homogeneity of the attack traffic is itself a signal. See [how accurate is browser fingerprinting](/blog/how-accurate-is-browser-fingerprinting) for more on accuracy relative to adversarial conditions.
Entropy, population, and the honest limits of the technique
Browser fingerprinting is a powerful tool for device identity, and the academic evidence, from Panopticlick through to the more recent amiunique.org longitudinal work, confirms that a well-constructed fingerprint can be highly identifying in realistic populations. But it is a probabilistic tool, not a cryptographic one, and treating it as though it provides guaranteed uniqueness is a design mistake.
The collision story is the consequence of finite entropy meeting large populations. Understanding it is what separates fingerprinting systems that work reliably in production from ones that produce mysterious false positives at scale. The answer is not less fingerprinting: it is more careful probabilistic reasoning about what a fingerprint match actually means.
For more on how fingerprints change over time (the related but distinct problem of drift and stability), see [fingerprint stability across browser updates](/blog/fingerprint-stability-across-browser-updates). For the underlying entropy concept, see [fingerprint entropy](/glossary/fingerprint-entropy).
Frequently asked questions
Can two devices have the same fingerprint?
Yes. Two physically distinct devices can produce identical or near-identical browser fingerprints. This happens when both devices have similar hardware, the same OS build, the same browser version, and similar default settings, because those shared characteristics mean the fingerprint carries little information that distinguishes them. It is especially common with fresh installs, corporate device fleets, and popular phone models running stock configurations. Multi-signal probabilistic scoring reduces the false-match rate by comparing more dimensions of similarity rather than relying on a single aggregate hash.
How unique is a browser fingerprint?
Uniqueness depends on the population. Research studies such as the EFF's Panopticlick project found that browser fingerprints carried around 18 bits of identifying information on average in their sample, which can distinguish hundreds of thousands of individuals. But uniqueness rates vary sharply by device type and drop significantly on mobile devices running common stock configurations. In a large-scale deployment across tens of millions of users, frequent collisions in the most common configuration bins are expected. Uniqueness is a property of entropy relative to population size, not an absolute property of the technique.
What causes fingerprint collisions?
Fingerprint collisions occur when two devices share enough of the same signals that their fingerprints come out identical or very similar. The main causes are: homogeneous hardware (popular phone models or identical corporate fleet images), default software configurations (fresh installs before any personalisation), browser version uniformity (when IT policy or auto-update timing means millions of devices share the same build), and deliberate normalisation (privacy browsers like Tor Browser that intentionally make every user look the same). Collisions are more likely in large populations because even a low per-pair collision probability adds up across millions of pairwise comparisons.
Get started
Go beyond single-hash fingerprinting
Probabilistic similarity scoring over multiple signals handles collisions that a single hash cannot distinguish. See the API reference or install doorman-benny to explore how multi-signal comparison works in practice.
Last reviewed July 12, 2026

