← back to blog

Building your own fingerprint test harness

Why a vendor’s “detection test passed” screenshot doesn’t tell you much

Every anti-detect browser vendor has a marketing page with a green checkmark on it. A screenshot of CreepJS or Pixelscan or some proprietary in-house tool, showing a profile that came back clean. It gets used as proof the product works.

It proves almost nothing about your setup.

That screenshot was taken on a specific OS, a specific browser build, through a specific proxy, on a specific day, with specific profile settings. You are not going to run that exact combination. You’re going to run your own OS templates, your own proxy pool, your own browser version pinned to whatever the vendor shipped last month, and your own mix of profile ages and usage patterns. Fingerprint spoofing quality is not a single fixed property of a product. It varies by release, by OS template, by whether you’re on residential or datacenter proxies, and by settings you may not even know you changed.

If you run more than a handful of profiles for real multi-accounting work, you need to stop trusting someone else’s screenshot and start generating your own evidence, against your own actual combination of tool, OS, browser version, and proxy. That’s what a fingerprint test harness is for. Not a one-off manual check in a browser tab, but a script you can point at any profile, any day, and get a structured answer back.

This piece is about how to build one. Not how to defeat a platform’s detection system. Those are different projects, and only one of them is defensible: knowing what your own tooling is actually doing before you deploy it, so you’re not flying blind on infrastructure you’re paying for and relying on.

What a fingerprint test harness actually is

Strip away the tooling and a fingerprint test harness is three things stitched together: a way to open a browser profile the same way your anti-detect tool opens it, a script that runs inside that page and pulls out every fingerprint-relevant value the page can see, and a place to store and compare the results.

The key design constraint is that it has to test the actual rendered browser window your anti-detect tool produces, not a vanilla browser you spin up separately. A lot of people’s first instinct is to write a Puppeteer script that launches its own Chromium and pokes at it. That tells you about Puppeteer’s Chromium. It tells you nothing about the profile injection, canvas noise, WebGL overrides, or UA rewriting that your actual multi-accounting tool applies, because none of that code ever runs in a browser you launched yourself.

The harness has to attach to the browser instance the anti-detect tool starts, usually through the local automation port or API most of these tools expose for exactly this purpose, and drive that instance. What you get back is real: the actual JavaScript environment a website will see when that profile visits it.

Once you can reliably attach and extract data, the rest is repeatable. You define a fixed set of checks, run them against a profile, store the JSON, and now you have something you can rerun after every provisioning batch, every proxy rotation, and every vendor update. That repeatability is the entire value. A single manual check tells you about one profile on one day. A harness tells you about drift over time, which is the thing that actually burns operators.

The fingerprint surface you need to cover

A browser exposes far more identifying data than most people realize, and no single value matters on its own. What matters is the full set, taken together.

The categories worth capturing: canvas rendering output, WebGL vendor and renderer strings plus a handful of parameter queries, AudioContext output, installed font list (inferred, not directly readable), navigator properties like userAgent, platform, language and languages, hardwareConcurrency, deviceMemory, screen dimensions and color depth, timezone via the Intl API, WebRTC-exposed IP addresses, HTTP client hints, and the plugin and mimeType arrays that older sites still check.

None of these on their own is a smoking gun. A rare canvas hash isn’t suspicious by itself, since plenty of real hardware produces uncommon output. The signal comes from combinations: does the claimed platform match the claimed GPU renderer string, does the claimed timezone match the IP’s geography, does the claimed hardware concurrency make sense for the claimed device class. A harness that only records raw values without checking them against each other is half-built. The comparison logic between fields is where the actual work is.

Build your capture script once, as a single JavaScript payload you inject via CDP’s Runtime.evaluate or Playwright’s page.evaluate, and have it return one structured JSON object per page load. Keep the schema stable across runs so you can diff historical results without writing a new parser every time you add a field.

Consistency scoring vs raw entropy

There are two different questions you can ask about a fingerprint, and conflating them is a common mistake.

The first is “how rare is this fingerprint.” This is the entropy question, the one tools like CreepJS and AmIUnique are built around: given this exact combination of values, how many browsers on the internet would produce the same set. A highly unique fingerprint is easier to track across sites even without cookies, because it narrows the pool of matching visitors down toward one.

The second is “does this fingerprint make internal sense.” A UA string claiming Windows 11 paired with a WebGL renderer string that reads like a mobile GPU driver. A timezone of America/Chicago on a connection geolocating to Jakarta. A language list of only Vietnamese on a profile whose UA claims a US locale. These are contradiction problems, and they’re far cheaper for a detection system to check than entropy scoring is.

Rarity alone doesn’t prove automation, because plenty of legitimate users run uncommon hardware or unusual browser configurations. Internal contradiction is a much stronger signal, because there’s no innocent explanation for a browser reporting two mutually exclusive facts about itself. This is presumably why platform-side detection systems weight consistency checks heavily.

Your harness should be built primarily as a consistency checker, with entropy or rarity data pulled in as a secondary input where it’s cheap to get, not the other way around. Catching a claimed-OS-versus-actual-renderer-string mismatch across your whole profile pool is a far higher-value use of your time than chasing a marginally lower entropy score on a profile that’s already internally coherent.

Picking your automation layer

You have three realistic options for the automation layer: Playwright, Puppeteer, or raw Chrome DevTools Protocol calls. All three can attach to an existing browser instance via its remote debugging endpoint, which is the part that actually matters. The choice between them mostly comes down to what your team already knows and what libraries you want for parsing results.

Playwright has the edge if you want to run checks across Chromium, Firefox, and WebKit-based profiles from one codebase, since several anti-detect tools support more than one underlying engine. Puppeteer is lighter if you’re Chromium-only, which covers most anti-detect browser products since most of them fork Chromium. Raw CDP calls make sense if you’re already deep in a language without solid Playwright or Puppeteer bindings and just need Runtime.evaluate and Network.getResponseBody.

The non-negotiable part, regardless of which library you pick, is connecting to the debugging port the anti-detect tool exposes for its own launched instance, rather than starting your own browser process. Most desktop anti-detect browsers expose a local API for exactly this kind of automation, since their own customers need to drive profiles programmatically for scraping and account management work. Find that local API’s documentation for the specific tool you’re using, get the profile’s debugging websocket URL from it, and attach your harness there.

Keep a thin adapter layer between your harness logic and the specific automation library. Vendors change their local API shapes between versions, and you don’t want a broken endpoint URL to force a rewrite of your entire fingerprint extraction script. Separate “how do I get a page handle” from “what do I do with a page handle” from the start.

What to actually capture in each run

Here’s a concrete list worth capturing on every run, all extractable via page.evaluate or Runtime.evaluate:

navigator.userAgent, navigator.platform, navigator.language and navigator.languages, navigator.hardwareConcurrency, navigator.deviceMemory, screen.width, screen.height, screen.colorDepth, Intl.DateTimeFormat().resolvedOptions().timeZone, a canvas fingerprint hash (draw a fixed shape with fixed text, call toDataURL(), hash the output), the WebGL UNMASKED_VENDOR_WEBGL and UNMASKED_RENDERER_WEBGL parameters via the debug renderer info extension, an AudioContext fingerprint (generate a fixed oscillator tone, read back the buffer, hash it), an inferred font list (measure text width across a fixed set of candidate font names against a fallback and record which ones differ), and WebRTC-exposed IPs gathered from ICE candidates.

Store each run as one JSON object with a profile ID, a timestamp, and every field above, plus whatever proxy you had assigned to that profile at run time so you can cross-check IP-derived fields against it later. Append rather than overwrite, so you’re building a time series per profile, not just a current snapshot. That history is what lets you catch the moment a vendor update silently changed how canvas noise is applied, rather than discovering it three weeks later when a batch of accounts all get flagged the same day.

Run the capture script multiple times within a single page session before moving to the next profile. A single snapshot can’t tell you whether a value is stable session over session, and stability itself is a data point worth having, covered more in a later section.

WebRTC leaks: the one that burns real operators

Of everything on the list, WebRTC leaks are the one that causes real, immediate damage, because they can expose your actual network path underneath a proxy that’s supposed to be hiding it.

WebRTC needs to gather ICE candidates to set up peer connections, and that gathering process can surface IP addresses the rest of the browser never reveals: your local network IP, and in some configurations the host machine’s real public IP, even when every other request from that page is correctly routed through your proxy. mDNS obfuscation of local candidates helps, but it doesn’t universally close the hole, and proxy configuration that only touches the browser’s regular network stack (SOCKS or HTTP proxy settings) doesn’t automatically catch WebRTC traffic unless the anti-detect tool specifically routes it too.

Here’s the concrete failure mode worth testing for directly: you assign a profile a residential proxy geolocating to Jakarta. Every request the harness makes through fetch() or by loading a page correctly shows a Jakarta-exit IP. But your harness also opens an RTCPeerConnection, triggers ICE candidate gathering, and reads back a candidate that resolves to your farm host’s actual public IP in a completely different country. That’s a hard, unambiguous leak, and it defeats the entire purpose of the proxy for that profile.

Build this check as its own dedicated test, not a side effect of the general capture script: create an RTCPeerConnection with a STUN server configured, listen for icecandidate events, parse out any IP addresses from the candidate strings, and compare every one of them against the proxy’s known exit IP (which you can get by hitting an IP-echo endpoint through the same proxied connection separately). Any mismatch is a fail, full stop, and it should be treated as higher severity than anything else on this list.

Canvas, WebGL, and audio noise: testing consistency across repeats

Most anti-detect browsers add deliberate noise to canvas, WebGL, and audio output to break the cross-site correlation that raw hardware fingerprints would otherwise allow, since without noise, every site you visit sees the exact same canvas hash and can link your visits together regardless of cookies.

Good noise implementations are stable within a session: the same profile, asked the same question twice in the same browser session, returns the same noised value both times. That’s what real hardware does too, so it’s what a convincing spoof needs to replicate. A bad implementation goes wrong in one of two directions. Either it doesn’t actually apply any noise at all, silently returning the real underlying hardware’s raw canvas output, which defeats the point of using the tool. Or it applies fresh random noise on every single call, which is its own tell, because genuine hardware never produces a different canvas hash for an identical draw operation call to call within one session.

This is exactly why your harness should call the canvas, WebGL, and audio fingerprint functions several times in a row within one page session before moving on, not just once. Diff the results against each other. If you see the same value every time, that’s the expected stable behavior. If you see it change between calls, flag it specifically, since that’s a distinct signal from “the value looks wrong,” it’s “the value is unstable in a way real hardware wouldn’t be.”

Worth noting: a harness can tell you that a value is unstable within a session. It generally can’t tell you on its own whether the noise algorithm is good enough to resist more sophisticated correlation attacks that look at the statistical distribution of the noise itself across many profiles, rather than just checking for a fixed hash. That’s a harder problem, and outside the scope of what a script you write in an afternoon can meaningfully verify.

Aligning timezone, locale, and IP geolocation

This is the cheapest, highest-value check on the whole list, and it belongs near the top of your harness, not buried at the end.

Every proxy has an associated geolocation, even if approximate. Every browser reports a timezone via the Intl API and a locale via navigator.language. These three facts, IP geography, reported timezone, and reported locale, should all agree with each other, and checking whether they do is a five-line comparison, not a research project.

Concretely: through the profile’s assigned proxy, hit an IP geolocation lookup and get back an expected country and expected timezone. Then read Intl.DateTimeFormat().resolvedOptions().timeZone from the page and compare it to what the IP suggests. Read navigator.language and check it’s plausible for that country, not a hard match since plenty of people browse in a second language, but a jarring mismatch (an IP in Vietnam paired with a browser reporting en-US as the only language with no others in the list) is worth flagging.

This is the kind of check that platform-side detection systems almost certainly run as a first-pass filter, because it’s computationally trivial compared to entropy analysis or behavioral scoring, and it catches a meaningful share of poorly configured setups. If your harness only builds one comparison check before you run out of time, build this one.

Note the direction of causality carefully in your harness logic: the IP is ground truth, since that’s what the far end of any real network request actually sees, and the browser’s self-reported timezone and locale are the values that need to match it, not the other way around. A profile provisioning workflow that sets timezone based on some fixed OS template rather than reading it from the assigned proxy’s actual geolocation is a common source of drift here, especially once you start rotating proxies across a pool of already-provisioned profiles.

Fonts and hardware claims

Font lists can’t be read directly from the DOM anymore in most modern browsers, but they can be inferred. The standard technique measures the rendered width of a string in a candidate font against its width in a known fallback font; if the widths differ, the candidate font is installed, if they match, it probably isn’t (the browser silently substituted the fallback). Run this across a fixed list of 30 to 50 common font names per major OS and you get a reasonably reliable inferred font list per profile.

That font list needs to be plausible for the claimed platform. A UA string claiming macOS paired with an inferred font list full of Windows-only system fonts and none of the standard macOS system fonts is a contradiction worth catching, and it’s the kind of thing that happens when a profile template’s spoofed UA gets updated but the underlying font spoofing configuration doesn’t get updated to match.

Hardware property claims need the same plausibility check. navigator.hardwareConcurrency and navigator.deviceMemory should fall within a range that’s realistic for the claimed device class. A UA claiming a mobile Safari session on an iPhone paired with hardwareConcurrency reporting 32 is not something any real iPhone reports, and it’s an easy, cheap check to build: maintain a small reference table in your harness of plausible ranges per platform category (desktop Windows, desktop macOS, Android mobile, iOS mobile) and flag anything reported outside that table’s range for the claimed category. It won’t catch subtle spoofing, but it catches the sloppy kind, which is more common than people expect once you’re running dozens of profile templates and some of them fall out of sync after a partial update.

Building a test matrix, not a single check

One profile passing your harness once tells you almost nothing about the fifty or two hundred other profiles you’re actually running, across different OS templates, browser versions, and proxy types. Fingerprint spoofing quality isn’t a single fixed property of a vendor’s product, it varies by which OS template a profile is based on, which browser build it’s pinned to, and what kind of proxy is attached to it at the time.

Structure your harness around a matrix, not a single test run. Cross every distinct OS template you use against every browser version currently in your active pool against every proxy type (residential, datacenter, mobile) you have profiles assigned to. Run the full check set against a sample from every cell in that matrix, not just the cell you happen to be looking at today.

This matters because failures cluster. A canvas noise regression introduced in a vendor update might only affect the Windows-based Chromium template and leave the macOS template untouched, or it might only manifest on datacenter proxies where the timezone-to-IP alignment logic behaves differently than it does for residential exits. A single spot-check on one profile you like will miss all of that.

Run the full matrix on a schedule, not ad hoc: after every batch of new profile provisioning, after every anti-detect tool update you apply, and on some regular cadence (weekly is reasonable for an active farm) even when nothing has obviously changed, since vendors ship updates silently and you won’t always know one landed until your matrix run shows a cell that used to pass now failing.

Regression testing against public scanners

Alongside your own capture script, it’s worth folding in results from public fingerprint scanning tools like browserleaks.com, pixelscan.net, and CreepJS’s entropy report, treating them as one more input source your harness scrapes the same way it scrapes your own checks.

These are useful as a floor, not a ceiling. They’re public, free tools, which means detection engineers building platform-side anti-fraud systems have almost certainly studied them too, and any fingerprint configuration that fails a widely available public check is failing something trivially easy to catch. Passing these public scanners tells you the known, published checks are covered. It doesn’t tell you anything about detection logic a platform has built in-house and doesn’t publish, which is where the more sophisticated fraud teams actually operate.

Automate the scrape the same way you automate your own capture: load the scanner’s page through the profile’s browser instance, wait for its results to render, and pull the structured output (or at minimum, take a screenshot and OCR the summary if the site doesn’t expose clean structured data). Store it alongside your own capture results in the same time series, so a regression on a public scanner and a regression in your own consistency checks show up together and you can see whether they correlate.

These tools are one signal among several, useful for catching the obvious stuff cheaply, but a clean CreepJS report only proves the known public checks are covered, not anything beyond that. Treat a perfect score as a floor to clear, not the goal of your testing strategy.

What this harness cannot tell you

Worth being direct about the limits here, because it’s easy to build a harness, watch it go green across your whole matrix, and start treating that as a guarantee. It isn’t one.

Everything described above tests static, JavaScript-exposed fingerprint vectors: values a page can read directly off the browser through standard APIs. Real platform-side anti-fraud and anti-abuse systems, the ones actually deciding whether to flag or ban an account, weight a lot more than that. Mouse movement entropy and timing, typing cadence, how a session’s timing pattern compares to thousands of others from the same account cluster, login velocity across a network of accounts, device and account graph analysis that looks at relationships between accounts rather than any single session in isolation, and payment or behavioral signals that have nothing to do with the browser at all.

No harness running in a browser tab can simulate or verify any of that, because it happens on the platform’s servers, using data your harness has no access to and no way to reconstruct. A profile that comes back clean on every check described in this piece, internally consistent, no leaks, stable noise, plausible everything, has still told you nothing about whether the account behind it will get flagged for behaving like part of a large coordinated network, because a fingerprint harness has no way to see the network.

This is the honest ceiling on what any of this can do. Building a good test harness makes your fingerprint layer a smaller, more manageable source of risk. It does not make accounts undetectable, unbannable, or risk-free, and no anti-detect browser on the market removes that risk either, regardless of what their marketing screenshot says.

Running this at scale, and what breaks

Running this against a real pool of profiles rather than a handful in a test environment surfaces problems the small-scale version never does. Store every run in a real database rather than flat JSON files once you’re past a dozen or so profiles, since you’ll want to query across time and across profile easily, and flat files stop being manageable fast.

Build a simple dashboard or even a scheduled summary report that highlights new failures since the last run, rather than making a human scroll through every profile’s full result every time. What you actually care about operationally is drift, a profile or a whole OS template that used to pass a check and now doesn’t, not the full static state of everything.

Vendors change their spoofing implementation between releases without necessarily announcing it in terms you’d recognize as fingerprint-relevant. A changelog entry about “improved canvas rendering performance” can quietly change noise behavior. This is the practical argument for running the matrix on a schedule rather than only after updates you notice, and for keeping the update version pinned and logged alongside every run, so when a regression does show up you can correlate it against exactly which build introduced it instead of guessing across a window of several updates.

Expect some noise in your own results too. A geolocation lookup service having a bad day, a proxy exit rotating mid-test, a flaky page load. Build in a retry before treating a single failed run as a real regression, and only escalate once a failure repeats across two or three consecutive runs.

None of this is a one-time build. Treat it as ongoing infrastructure, maintained the same way you’d maintain any other piece of your operation, because the moment you stop rerunning it is the moment drift starts accumulating unnoticed.

A test harness like this won’t make your profiles undetectable and it won’t guarantee anything about outcomes. What it does is turn “I think this setup is fine” into “here’s what this setup actually reports, checked against itself, on this date.” That’s a meaningfully better place to operate from than trusting a vendor’s screenshot, and it’s the kind of groundwork worth doing before you scale a profile pool rather than after something’s already gone wrong.

For more on how anti-detect browsers actually work, what the major tools get right and wrong, and honest testing writeups without the vendor hype, check out the rest of Anti-Detect Review.

Get new guides and videos first — join the Telegram channel.

need infra for this today?