A browser fingerprint is not one value. It is a set of independently observable signals, gathered at five separate layers of the stack, and browser fingerprinting works because those layers are difficult to keep in agreement with one another.
The signals start arriving before your code runs. A TCP handshake, a TLS ClientHello, and an HTTP/2 SETTINGS frame all reach the server ahead of the first byte of HTML. By the time JavaScript executes, the server already holds a partial identity.
The W3C Group Note Mitigating Browser Fingerprinting in Web Specifications, published 25 September 2025, sets the scale plainly: “30-some bits of entropy would be enough to uniquely identify every individual person.” No single signal carries 30 bits. Twenty signals carrying one or two bits each do.
Umar Iqbal, Steven Englehardt and Zubair Shafiq measured the spread in Fingerprinting the Fingerprinters (IEEE Symposium on Security and Privacy, 2021): fingerprinting is present on more than 10% of the top-100K websites and over a quarter of the top-10K.
Layer 1: the network describes your socket before you send a byte
The network layer identifies the software that opened the connection, not the browser claiming to drive it. These signals come from the networking library and the kernel, below anything a page or script can rewrite.
HTTP/2 is the clearest illustration. Akamai’s Threat Research team (Ory Segal, Aharon Fridman and Elad Shuster) analyzed more than 10 million HTTP/2 connections across Akamai edge servers for the June 2017 white paper Passive Fingerprinting of HTTP/2 Clients. They showed that the SETTINGS parameters, WINDOW_UPDATE increment, PRIORITY frames and pseudo-header order concatenate into a compact string identifying the client implementation.
Their own examples make the point. Chrome 58 on Windows 10 produces 1:65536;3:1000;4:6291456|15663105|0. The OkHttp 3.6.0 library produces 4:16777216|16711681|0. Those are different implementations, and the fingerprint says so regardless of the User-Agent string the request carries.
RFC 7540 anticipated this. Section 10.8 warns that settings values, flow-control window management, stream priorities and reaction timing all let an observer correlate a client over time.
Layer 2: the HTTP layer, where you declare more than you meant to
The HTTP layer contributes header content, header order, and header casing. Two clients can send an identical set of headers and still be told apart by the order they send them in, which reflects an implementation detail rather than a configuration choice.
User-Agent Client Hints changed the shape of this layer. Per MDN Web Docs, low-entropy hints such as Sec-CH-UA, Sec-CH-UA-Mobile and Sec-CH-UA-Platform ship by default. High-entropy hints (Sec-CH-UA-Model, Sec-CH-UA-Arch, Sec-CH-UA-Full-Version-List, Sec-CH-UA-Platform-Version) arrive only when a server opts in with an Accept-CH response header.
The design detail that matters for automated traffic is the Sec- prefix. These are forbidden header names, so page JavaScript cannot modify them. The browser answers about itself, and its answer has to agree with everything the layers above and below it report.
Layer 3: the JavaScript API layer enumerates the browser to itself
The JavaScript layer is the one most people mean when they ask how browser fingerprinting works. A script reads navigator, screen, the installed font list, timezone, language, hardwareConcurrency, deviceMemory, and the presence or absence of specific APIs.
The W3C note draws a line between this layer and everything above it. Passive fingerprinting works “based on characteristics observable in the contents of Web requests, without the use of any code executed on the client”. Active fingerprinting “runs JavaScript or other code on the local client to observe additional characteristics”.
That distinction has a practical consequence. Active fingerprinting is detectable by the client, which is why privacy tooling can intervene here and not below. It is also why this layer is the easiest to alter and the least useful to alter alone.
Layer 4: the hardware layer measures silicon, not settings
Canvas and WebGL fingerprinting do not read a value the device reports. They ask the device to render something and measure the result, making the output a function of the actual GPU, driver and compositing pipeline.
The sharpest example arrived at NDSS in February 2022. In DRAWNAPART, Tomer Laor, Naif Mehanna, Antonin Durey, Vitaly Dyadyuk, Pierre Laperdrix, Clémentine Maurice, Yossi Oren, Romain Rouvoy, Walter Rudametkin and Yuval Yarom used unprivileged JavaScript to time WebGL vertex-shader execution across a GPU’s parallel execution units.
Manufacturing variance means those units run at fractionally different speeds. The resulting trace separates two devices carrying the identical GPU model, and the paper reports it extends device tracking time by up to 67% over prior methods.
An emulator has to synthesize hardware it does not have. Every canvas readback, WebGL renderer string and shader timing has to be manufactured and then held consistent with every other reported value, through driver updates on both sides. Archonum made that case in detail in why real devices beat emulators.
Layer 5: the behavioral layer watches what happens after the page loads
The behavioral layer stopped being a research curiosity and became shipped infrastructure. Cloudflare launched Precursor on 13 July 2026, describing it as a system that “uses dynamically injected JavaScript to continuously collect behavioral signals as visitors interact with your application”: pointer movement, keyboard timing and rhythm, focus changes and page visibility.
Cloudflare’s stated reasoning is physical rather than statistical. Human pointer movement is an arc constrained by wrist and forearm rotation. There is a measurable delay between seeing a target and clicking it. Even a steady hand oscillates at a physiological tremor frequency. Synthetic movement, the company notes, tends toward linear interpolation or mathematically ideal Bézier curves, with click precision no human achieves.
You cannot configure your way past this layer, because it is not reading a value. It is watching for a hand.
What each signal reveals, and how hard it is to fake
| Layer | Signal | What it reveals | Difficulty to fake |
|---|---|---|---|
| Network | TCP/IP stack behavior | Host OS and network path | High. Kernel-level |
| Network | TLS ClientHello composition | The TLS library used | High. Set by the networking stack |
| Network | HTTP/2 SETTINGS, WINDOW_UPDATE, PRIORITY | The HTTP client implementation | High. Documented by Akamai in 2017 |
| HTTP | Header order and casing | Client implementation lineage | Moderate. Must match exactly |
| HTTP | Sec-CH-UA client hints |
Browser brand, version, platform, device model | Moderate. Unreachable from page JS |
| JS API | navigator, screen, fonts, timezone |
Configuration, locale, software environment | Low individually, high in combination |
| JS API | API presence and permission states | Whether the runtime is what it claims | Moderate. A missing API is as loud as a wrong one |
| Hardware | Canvas and WebGL render output | GPU model, driver, compositing pipeline | High. Measured, not reported |
| Hardware | GPU execution-unit timing | The individual unit, not the model | Very high. Manufacturing variance (NDSS, 2022) |
| Behavioral | Pointer arc, tremor, cognitive delay | Whether a human hand is present | Very high. Physics rather than values |
What a browser fingerprinting test can and cannot tell you
Run a browser fingerprinting test on a public checker such as AmIUnique or the EFF’s Cover Your Tracks and you get one layer’s answer, usually the JavaScript one, scored against that site’s own visitor population.
That is a useful diagnostic and an incomplete one. A public checker cannot see the HTTP/2 fingerprint your client produced, and it cannot see whether your session’s pointer movement reads as human. A production detector correlates all five layers and weighs contradictions between them more heavily than any single value.
The layered view changes what the problem is
Once you see fingerprinting as five layers rather than one script, the maintenance arithmetic gets clear. Masking the JavaScript layer leaves four layers untouched, and every masked value adds a constraint that has to hold against every other layer, through updates on both sides, indefinitely.
Consistency is the target, not concealment. Detection systems are not mainly asking whether a value looks unusual. They are asking whether the values contradict each other.
This is the reasoning behind how Archonum is built. Archonum runs AI-agent browser workloads on 250,000+ real consumer smartphones across 175+ countries, with the browser and the exit IP on the same handset: one network hop, no proxy split, no cloud instance in front. The TLS stack, the HTTP/2 frames, the client hints, the GPU and the hand holding the phone all belong to the same real device.
There is nothing to keep consistent, because nothing was ever synthesized. That is the difference between maintaining a fingerprint and having one.