Fingerprint checker
See, right now and in this browser, what you hand to every site you open — and where those signals contradict each other.
Every test on this page executes in your own tab, in JavaScript. None of the values shown here are uploaded, stored, or logged on our servers. No sign-up, no tracking cookie, and no test history on your side or ours — reload the page and it starts from nothing.
One honest exception: your public IP is not something the page uploads — it is the connection itself. Every server on the internet already sees it the moment a page loads. What matters is what happens next: city, network operator and network type are resolved against databases sitting on our own server disk. No lookup ever leaves this machine, your address is never handed to a third party, never logged, never stored and never turned into a metric.
What a browser fingerprint actually is
A fingerprint is the set of characteristics your browser hands to every site you open, without asking permission and without showing up anywhere in the interface. None of them identifies you on its own: millions of people share your screen resolution, and millions share your language. The problem is the combination. Resolution, time zone, font list, GPU model, core count and another two dozen details form a set that, in practice, repeats rarely — and that is what lets a site recognise the same visitor across different accounts, different sessions, long after the cookies were cleared.
The reading above happened in your browser, just now. If you open this same page in another profile, in a private window, or after switching proxies, and the values stay the same, that is exactly what the site on the other side sees too.
Why contradictions matter more than values
Having an unusual fingerprint does not get accounts banned. Inconsistency does. A fraud system does not need to prove who you are; it only needs two signals that should agree and do not. When the user agent says Windows and the graphics driver hands over a Linux string, there is no innocent explanation — no machine on earth ends up in that state by accident.
That is why the tool above does not stop at listing values. It cross-checks the ones that have to line up:
navigator.platform,navigator.userAgentDataand the user agent string, which come from the same browser and always tell the same story on a real system;- the WebGL renderer against the declared operating system — the driver is the hardest part to fake convincingly;
- the installed fonts against the declared system, because every system ships its own set from the factory;
- the time zone and language against the country your connection exits from;
- a mobile user agent against the existence of touch points, which is the classic mistake of anyone who changed only the string.
Canvas and WebGL
The canvas test asks the browser to draw the same figure and reads the image back as bytes. The result varies from machine to machine because of anti-aliasing, driver version and available fonts — two machines that look identical on paper produce different images. The hash shown above is the summary of that image.
WebGL goes further and hands over the commercial name of your graphics card through the WEBGL_debug_renderer_info extension. It is one of the most stable identifiers there is, because it follows the hardware rather than the session. Blocking both is possible, but blocking is a signal of its own: a browser that refuses to draw belongs to a small minority, and small minorities are easy to group. The full detail is in canvas and WebGL fingerprinting.
The layer this page cannot read: JA3 and JA4
There is one signal no browser-side tool can show you honestly, and it happens to be the one that takes down otherwise well-built setups: the TLS handshake fingerprint.
When your browser opens an HTTPS connection, the first thing it sends is the ClientHello — a packet declaring which TLS versions it accepts, which ciphers, in what order, which extensions, which elliptic curves. Every client assembles that packet its own way. JA3 and JA4 are summaries of it, and they act as a signature of the program doing the talking, not of the user.
That packet is read by the server, not by the page. JavaScript runs afterwards — long afterwards — and no browser API exposes what was negotiated. Which means there is no way to measure your own JA3 from a web page. A site displaying "your JA3" is either measuring it at its own edge or printing a number on the screen. We do not print numbers.
The honest path is a TLS client that negotiates exactly the way Chrome negotiates — same cipher order, same extensions, same GREASE behaviour. How that works underneath is in JA3 and JA4 explained.
What to do with the result
If the page flagged contradictions, start with the high-severity ones: those are what a detection system sees with no effort at all. Coherence between declared system, driver, fonts and time zone is worth more than any attempt at being unique or invisible.
If it flagged nothing, good — but remember this page only measures what JavaScript can reach. The TLS layer, HTTP/2 behaviour and the reputation of your IP block stay outside the reach of any browser-side test. Read why accounts get banned for the full picture, and why user agent spoofing is not enough if you arrived here believing the string was the whole job.
About whoever built this tool
AlterAntiX is a desktop anti-detect browser: isolated profiles, each with its own coherent set of signals — including the TLS layer, which is where most setups slip. The free version does not ask for a card.