Fingerprinting

What is Browser Fingerprint?

A browser fingerprint is an identifier derived from the properties your browser exposes - user agent, screen and window dimensions, timezone, language, installed fonts, canvas and WebGL rendering output, audio stack behaviour, hardware concurrency. Combined, these values are often unique enough to recognise the same browser across sessions and sites without any cookie.

A fingerprint is assembled from values a page can read without asking permission. JavaScript reports navigator properties, screen and viewport dimensions, device pixel ratio, timezone offset, the language list, hardware concurrency and an approximation of how much memory the device claims. Fonts are detected by measuring rendered text width with candidate families applied and watching which measurements change. Any single value is common. The combination carries enough entropy to pick one browser out of a very large population, which the EFF's Cover Your Tracks project illustrates by scoring how rare a visitor's configuration is.

The strongest signals come from asking the machine to render something. A canvas draws text and shapes offscreen and the page hashes the resulting pixels; GPU, driver version, font rasteriser and antialiasing settings each shift the output a little, so the hash stays stable on one device and differs across devices. WebGL adds vendor and renderer strings along with the result of drawing a shaded scene. An AudioContext run through an oscillator and a compressor yields a comparable value from the audio stack. None of this triggers a permission prompt.

Detection systems care less about any single value than about whether the set agrees with itself. A user agent claiming Safari on an iPhone alongside Chrome-only APIs, a timezone in Europe behind a US exit address, a WebGL renderer reporting SwiftShader or llvmpipe where a consumer GPU belongs, a resolution no shipping device uses - each contradiction is cheap to test and awkward to fake. Headless runtimes add markers of their own unless they are patched, and patching one property while leaving the related ones untouched creates a fresh contradiction.

A proxy changes the network layer and leaves all of this untouched. Two accounts driven from the same browser profile share a fingerprint even on separate mobile IPs, and a site storing that hash links them whatever the routing says. Antidetect browsers exist for this reason. Each profile pins a coherent set of values and reuses them, so an identity looks like one ordinary device coming back rather than a new machine every session. Randomising everything per request is worse than pinning, because a configuration nobody has ever seen is itself a signal.

Where you meet it

You meet this the day two accounts get actioned together and neither shared an IP. It also explains why a scraper that passes on your desktop fails in CI, since the container has no GPU, so the WebGL strings change and the canvas hash lands in a bucket the target associates with automation. Before buying more proxies, run the profile through a fingerprinting test page and compare the result against the device you are claiming to be.

Common questions

Does a proxy change my browser fingerprint?

No. A proxy changes the address your traffic comes from and nothing the browser reports about itself. Canvas hashes, fonts, screen size, timezone and the rest are read locally and stay identical through any proxy. Only signals derived from the IP itself, such as geolocation lookups, change when you route differently.

How is a browser fingerprint different from a cookie?

A cookie is data the site stores on your machine, which you can inspect and delete. A fingerprint is computed fresh on each visit from properties your browser already exposes, so clearing storage, switching to a private window or blocking third-party cookies leaves it intact. Nothing is written to disk to remove.

Can I block browser fingerprinting?

Partly. Tor Browser standardises values so many users look identical, Firefox has a resist-fingerprinting mode, and extensions can add noise to canvas readouts. Each approach reduces one form of entropy while making you unusual in another way, and some break sites outright. Pinning a plausible, consistent profile is generally more effective than hiding.

Related terms

TLS Fingerprint
A TLS fingerprint is an identifier derived from the ClientHello a client sends when it opens an HTTPS connection: the TLS version offered, the ordered cipher suite list, the extension list, supported elliptic curves and signature algorithms. JA3 and JA4 are the common encodings of it. Different HTTP clients and browsers produce visibly different values.
Device Fingerprint
A device fingerprint is an identifier built from the hardware and software traits a device exposes: screen geometry, GPU and driver strings, CPU core count, memory, timezone, languages, installed fonts, audio and canvas rendering, and touch support. Hashed together, those values are stable enough to recognise a returning device across sessions without any cookie.
JA3
JA3 is a TLS client fingerprinting method that reads five fields from the ClientHello, joins their decimal values into a single string and hashes it with MD5. The fields are TLS version, cipher suites, extensions, supported elliptic curves and EC point formats. The 32-character result groups clients by TLS library and configuration.
JA4
JA4 is the TLS client fingerprint in the JA4+ family published by FoxIO, designed to replace JA3. Rather than one opaque MD5, it produces a partly readable string: a ten-character prefix describing transport, TLS version, SNI, cipher and extension counts and ALPN, followed by two truncated SHA-256 digests of the sorted cipher and extension lists.
P0F
p0f is a passive OS fingerprinting tool that identifies the system behind a connection by watching traffic rather than probing it. It reads TCP SYN packets for initial TTL, window size, MSS, the order of TCP options and a set of quirk flags, then matches them against a signature database. It sends nothing to the host it identifies.
Canvas Fingerprint
Canvas fingerprinting draws hidden text and shapes into an HTML5 canvas, reads the pixels back with toDataURL or getImageData, and hashes them. The exact output varies with GPU, graphics driver, font rendering and anti-aliasing, so the hash stays stable for one device and browser build while differing between machines.
WebGL Fingerprint
A WebGL fingerprint is an identifier derived from how a browser's GPU and graphics driver render 3D content. Sites read the renderer and vendor strings the driver reports, then hash the pixels of a small scene drawn off-screen. Capability limits from the context add more. The result stays stable across sessions and changes only when the hardware or driver does.

Real 4G/5G mobile and residential IPs

PROXIES.SX runs carrier IPs in 100+ countries with HTTP and SOCKS5 on every endpoint. $4/GB down to $2.40/GB at volume, free endpoints and rotation, and your GB never expire.