The State of Browser Fingerprinting in 2026

Browser fingerprinting has become the primary tracking mechanism for advertisers and data brokers, and the reason is structural rather than technical. Cookies require storing something on a device, storage can be cleared, and clearing it is now a one-click operation surfaced by browsers themselves. A fingerprint stores nothing. It is recomputed on demand from properties of the machine and the connection, which means there is nothing for a user to delete and nothing for a browser to offer to delete on their behalf.

In 2026 the work is done in three layers, and it is worth separating them because the defences are completely different.

The first layer is passive and happens before a single line of your JavaScript runs. The way a client negotiates TLS — its cipher suite ordering, its extensions, its supported groups — forms a signature, and so does the shape of its HTTP/2 connection: the SETTINGS frame values, the header ordering, the priority information. None of this is volunteered by the page. It is a by-product of how the client was built, which makes it a reliable way to tell what is really connecting, and a reliable way to catch a client claiming to be something it is not.

That last point is the one people underestimate. Passive signatures are most often used not to identify an individual but to check a claim. A user agent string saying one browser on one operating system, arriving over a TLS handshake characteristic of a different stack entirely, is a contradiction that requires no fingerprinting database to notice — just a comparison between two things that should agree.

The second layer is active measurement in the browser. Canvas and WebGL rendering differ subtly across GPU, driver, and OS combinations. AudioContext processing produces small floating-point differences by platform. Font availability, screen and window geometry, device pixel ratio, hardware concurrency, device memory, platform strings, and timezone are all readable, and WebGPU has widened this considerably by exposing far more detailed adapter and limits information than the older APIs did.

The third layer is behavioural, and it is increasingly layered on top rather than used alone: pointer movement characteristics, typing cadence, scroll dynamics, and the timing between interactions. This layer does not identify a machine so much as a person, which is precisely why it is being adopted — it survives changes to the machine.

The crucial thing to understand about all three is that no single value identifies anyone. What identifies you is the combination, and specifically how rare the combination is across everyone else being measured. This is an entropy problem, not a secrecy problem. A widely shared screen resolution contributes almost nothing. That resolution together with a particular GPU string, a particular font set, and a particular timezone can be close to unique.

This is what makes the popular defence backfire. Randomising fingerprint values on every page load feels like it should help, and it does prevent a stable identifier from forming. But it also produces something no genuine browser produces: a canvas hash that differs between two loads on the same device, a font list that changes between visits, a GPU string that does not match the platform reporting it. Values that shift when they should be stable are themselves rare, so randomisation trades a stable identifier for a loud anomaly. Anti-fraud systems have caught up with this, and they no longer need to know who you are to decide something is wrong.

The same argument sinks the more casual version, where someone edits a user agent string and considers the matter handled. The browser is still reporting its real platform in a dozen other places, still rendering canvas the way its real GPU does, and still negotiating TLS the way its real stack does. A single edited value in a set of otherwise consistent ones is not camouflage; it is the one thing that stands out.

So the goal is not to be unrecognisable, which is not achievable, and not to be random, which is worse than doing nothing. The goal is to be unremarkable and consistent: a combination of values that is common, that agrees internally, and that stays the same for that identity over time — because real devices do not change their GPU between Tuesday and Wednesday.

This is the design Persona Kit works toward. Each persona carries its own device profile — device, operating system, screen, language, timezone — generated to agree with where the persona claims to live, so the measured values and the stated identity do not contradict each other. Sessions run in an isolated browser rather than on your own hardware, so what is measured is a property of the persona rather than your laptop reported repeatedly under different names. And session state is restored on each launch, so a returning persona presents the same profile it presented last time instead of arriving new every visit.

It is worth being honest about the limits. This is not a claim that fingerprinting is defeated, and anyone selling that claim is selling something. Passive network-level signatures are a property of the client stack. Behavioural signals belong to whoever is at the keyboard. What is achievable is narrower and more useful: not being the one profile in the set whose values contradict each other, and not being linked to your other identities through a fingerprint you were reusing without realising it.