If you pulled apart the who.1ms.dog self-check tool, the part worth keeping isn't the collection of client-side probes. The author lists 71 "sniffers" that read what a normal web page can already touch: no permission prompts, no camera, no location box. Those are table stakes. The real product sits on the right side of the page: 9 disguise checks that catch where your signals contradict each other. That's the piece a small team should rebuild, and it maps cleanly onto a hosted HTML page plus a Python endpoint.
I'll walk through what the tool proves, why the mismatch logic outlasts the probe list, and exactly where VicroCode's confirmed capabilities carry it, and where they don't.
What does the fingerprint tool actually prove?
It proves that a proxy only moves your IP, not everything a site reads about you. The author ran a Japanese node, Amazon datacenter IP geolocated to Tokyo, and the page still concluded "you're probably Chinese, currently in Tokyo." The IP changed; the timezone stayed UTC+8, the browser language stayed Chinese, and the DNS resolver stayed domestic. WebRTC went further and reported the home China Unicom IPv6 directly. WebGL named the GPU as an RTX 4080 SUPER.
None of that needed a permission dialog. The lesson for a builder: a single swapped signal doesn't make a consistent identity, and sites exploit the gaps.
Why is the mismatch logic the durable half?
Because raw signals go stale, but contradictions keep working. The 71 probes change every browser release as APIs get deprecated or gated. The 9 disguise checks encode a more stable idea: timezone versus IP country, browser language versus IP country, DNS resolver location, traffic splitting (domestic sites, foreign sites, ChatGPT and Claude seeing different exits), WebRTC leaking the real address, datacenter IP, UA claiming Mac while the GPU is NVIDIA, a fingerprint stable enough to re-identify you, and `navigator.webdriver` being true.
The author went from 7 flagged items to 2 after following the fixes, and the two that stuck were the datacenter IP and the stable fingerprint, both outside easy reach. That result is self-reported and unverified, but the structure is the takeaway: the value is the comparison, not the reading.
How do you split client reads from server signals?
Put the browser reads on a static page and the server reads behind one endpoint, then compare. The client page collects what JavaScript exposes: timezone, `navigator.language`, screen and refresh rate, WebGL renderer string, thread count, `navigator.webdriver`. You can build and run HTML online so the page serves directly without a separate front-end host.
The server half is a single handler that returns only what the request already carries: the IP, the request headers, and whatever geolocation the runtime provides. You run Python online as an API endpoint, do the timezone-versus-IP and language-versus-country comparison there, and return the flags. Keep it stateless, log nothing, and the original tool's privacy posture holds: the backend sees only what this request would have shown any server anyway.
For the external-exit checks (which exit domestic sites versus ChatGPT and Claude see), the page requests outside services and compares the IPs it gets back, exactly as the original does. That logic lives client-side because it's the browser's own exits you're measuring.
Where does VicroCode fit, and where does it stop?
It fits the three pieces you'd actually ship: the page, the comparison endpoint, and distribution. Once the page and endpoint work, project publishing and web app hosting let you put it behind a URL, share it, and gate it if you want. A SQLite table is enough if you later decide to store anonymized flag counts, though the original keeps the fingerprint record in the user's browser only, and that's the cleaner default to copy.
Where it stops matters more. The original runs on Cloudflare Workers and claims server-side signals like the nearest Cloudflare node and a TLS fingerprint. A Python endpoint sees the TLS handshake only if the runtime surfaces it; without that, JA3-style TLS fingerprinting is out of scope here and should be labeled unverified rather than promised. Treat it as a boundary, not a feature.
What can't you rebuild this way?
Anything that depends on a signal the runtime never hands you. WebRTC leak detection works because the browser exposes candidate addresses to JavaScript, so that check survives the rebuild. DNS-leak detection depends on being able to observe which resolver answered, which the original does via external services from the client, not from the server; replicate it the same way and don't claim server-side DNS inspection you can't see.
TLS fingerprinting is the clearest limit. It needs access to the raw handshake, and a hosted Python handler only gets what the platform exposes above that layer. State that plainly on the page so a user who sees "TLS fingerprint: unavailable" knows it's an honest boundary, not a bug.
FAQ
Can I return a TLS fingerprint from the Python endpoint?
Only if the runtime exposes the handshake, which is not confirmed here, so treat TLS fingerprinting as unverified and label it unavailable rather than inventing a value.
Does the mismatch check need a database?
No. The comparison is stateless per request; the original keeps the fingerprint history in the user's browser, and a SQLite table is optional only if you later want anonymized aggregate counts.
Which checks survive the client/server split cleanly?
Timezone-versus-IP, language-versus-country, datacenter IP, and `navigator.webdriver` survive directly; WebRTC and DNS-exit checks survive because the browser exposes those signals to JavaScript, as the original tool shows.
Further reading
- The WebRTC specification describes the ICE candidate addresses that make WebRTC leak detection possible from the browser.
- MDN's navigator.webdriver page documents the automation flag the tool reads to detect scripted browsers.
- MDN's WebGLRenderingContext.getParameter covers the renderer string that exposes GPU models like the RTX 4080 SUPER.