All articles Advanced signals

What Is Browser Fingerprinting and How It Works

Translucent glass panels of device traits orbiting a glowing blue fingerprint on a black background

Browser fingerprinting is the practice of collecting the attributes a browser and device expose during an ordinary page load, then combining them into an identifier that survives cleared cookies, private windows and most privacy settings. A screen size describes millions of people; a dozen attributes read from the same session describe very few.

Risk teams use it to recognise a browser they have seen before: the laptop that opened a dozen trial accounts, the device behind an OTP pumping run, the session that appeared in two countries within an hour. Analytics teams use it to separate humans from bots and to meter a paywall per device rather than per cookie.

This post covers the signals involved, why some survive a browser update while others drift, and how to use fingerprinting in fraud prevention without turning it into a surveillance tool.

Which signals form a browser fingerprint

No single value identifies anything. The fingerprint is the combination, drawn from two places: what the page can compute in JavaScript, and what your server reads from the connection itself.

Signals the page can compute

  • User agent string, platform and advertised feature set
  • Screen resolution, color depth, pixel ratio and touch support
  • Time zone, language list and locale preferences
  • Hardware concurrency, device memory class and storage availability
  • WebGL and canvas rendering output, which depend on the GPU and its driver
  • Available fonts, measured indirectly by rendering text
  • Codec support, audio stack behaviour and permission states

Signals the server reads

Your server sees the IP address and can classify the network behind it: residential, mobile carrier, corporate, datacenter, or a VPN or proxy exit. It also sees the TLS handshake and the shape and order of HTTP headers, which vary by browser build and by the library a script uses. These network-level signals are harder for a page script to fake, because the client does not control them directly.

What a fingerprint cannot tell you

A fingerprint does not identify a person. It says that a browser configuration looks like one you have observed before, with some confidence. Two people sharing a work laptop share a fingerprint; one person with three browsers has three. Treat it as evidence, not as an identity.

How a fingerprint gets built and matched

Collection is the easy part. Matching is where implementations diverge:

Fingerprint pattern drawn with fine blue lines and connected nodes on a dark surface

signals    = collectStableFields(page, connection)
normalized = bucketVolatileValues(signals)  // screen, memory, fonts
id         = hmac(serverKey, normalized)    // keyed hash, not plain hash
match      = lookup(id, history)            // exact first, then fuzzy

Three decisions matter. Normalise the fields that flake: an exact screen size is noisy on multi-monitor setups, so bucketing it usually beats hashing it raw. Key the hash with a server-side secret so the stored value cannot be recomputed by anyone who knows the signal set. Keep the match score instead of a boolean: an exact match and a near match mean different things when you are deciding whether to let a login through.

Why one device produces several fingerprints

Browser updates, extension changes, a new monitor and a VPN toggle all move the signal set. A good implementation links near matches to the same visitor and records the drift, rather than treating each variation as a new device.

Why two devices produce the same fingerprint

Virtual machines, headless browsers and identical corporate hardware rollouts collide. Collisions are the main reason not to enforce on a fingerprint alone.

Stability across browser updates

Stability is not something you inherit; it is something you measure. Version strings change with every release, GPU renderer strings change with driver updates, and canvas output shifts when the rendering stack changes. Fields that look permanent in a test environment drift in production.

Two habits keep the match rate honest. Score volatile fields lower than structural ones: platform, time zone and network class age better than a version number. Then track the rate at which returning visitors fail to match, segmented by browser and operating system, so a browser release shows up as a measurable dip instead of a mystery. Our page on fingerprint accuracy explains how we report match quality and collisions.

The same signals, used to spot automation

Automation leaves traces in the fingerprint. A headless browser often advertises a combination no real device produces: a mobile user agent with no touch support, a desktop platform with a WebGL renderer found only on servers, or a header order that belongs to a scripting library rather than a browser. Contradictions like these are stronger evidence than any single flag.

Two similar device silhouettes, one layered with shifting translucent surfaces, on black

Network class adds context. A signup from a residential connection and a signup from a datacenter IP with an hour-old browser profile are different risk profiles even when the fingerprint matches. Our bot detection guide covers how to combine both signals and keep false positives away from logged-in customers.

Privacy-respecting uses in fraud prevention

Fingerprinting earns its place when it answers one question at a specific decision point, with a policy attached:

  • Login: is this the browser that usually signs into the account, or a new device that should step up to email verification?
  • Signup and trials: has this device already used the free trial, without blocking a shared family computer outright?
  • SMS and OTP: how many codes have this device, number and network requested in the last hour?
  • Checkout and bonuses: does this device match one already flagged for repeated promo abuse?

In each case the output should be a decision with a reason code — allow, step up, block — that your own code applies. Start in observation mode: record what the policy would have done, compare it with the outcome, then enforce. Keep retention short, tell users what you collect, and keep the data out of advertising. Our device fingerprinting page explains the hashing and retention choices we make.

FAQ

Does incognito mode stop browser fingerprinting?

Not by itself. A private window clears cookies and storage, but the device still reports the same screen, GPU, time zone and network class. Some browsers randomise or freeze parts of that surface, so the fingerprint becomes fuzzier rather than absent.

It depends on your jurisdiction, the data involved, and whether the fingerprint counts as personal data under local law — which is often the case when it is linked to an account. Disclose it, limit the purpose to security, keep it short-lived, and get legal advice for your market. We do not provide legal advice.

Can users reset a fingerprint?

Partly. Switching browsers, removing extensions, changing networks or moving to a new device changes the signal set. That is normal behaviour, which is why history and near-matches matter more than exact hashes.

Try it on your own traffic

Prynt Identify returns a visitorId plus bot, AI-agent, VPN and proxy signals, and your code decides what to do with them. The free plan includes 5,000 identifications a month, no card. Start at pryntid.com, read the Identify docs, and run the policy in observation mode before you enforce.

Try it free

Prynt is device intelligence with a free plan: 5,000 identifications a month, visitor IDs with confidence and bot detection — no credit card. Upgrade to Pro for VPN, proxy, tampering and behavioral signals.

Keep reading