← back to blog

What WebGPU Adds To The Detection Surface

What’s actually new here

WebGL has been the go-to GPU fingerprint source for years: renderer string, vendor string, a handful of extension flags, maybe a canvas hash. It’s a shallow API. You get what the driver decides to report through a translation layer built for graphics, not for identification.

WebGPU is a different animal. It was designed to give web pages closer-to-the-metal access to the GPU for compute and rendering, which means it exposes more of the actual hardware and driver stack than WebGL ever did. That’s good for game and ML workloads running in a browser. It’s also a much richer set of signals for anyone trying to tell real hardware apart from spoofed hardware.

I run proxy and cloud-phone infrastructure for multi-accounting, and I test anti-detect browsers against real detection scripts as part of that work. WebGPU support has been rolling into what I’m looking at over the last year or two, and it’s worth understanding what it actually leaks before assuming a tool “handles” it.

The adapter info: vendor, architecture, device

The core new object is GPUAdapter, and the method that matters is requestAdapterInfo(). Called on a real adapter, it can return a vendor string, an architecture string, and a device description. On a lot of real hardware this comes back specific: not just “NVIDIA” but something closer to the actual chip family or driver-reported architecture, depending on the browser and platform.

This is a step up from WebGL’s UNMASKED_RENDERER_WEBGL string, which is coarser and easier to template. WebGPU’s adapter info sits closer to what the OS and driver actually know about the card, which makes it harder to produce a value that’s internally consistent with everything else the page can see.

Limits and supported features as a fingerprint

Every GPUAdapter reports a limits object: max texture dimensions, max buffer sizes, max compute workgroup size, max bind groups, and a couple dozen other numbers. These aren’t arbitrary. They come from real hardware and driver constraints, so they cluster by GPU generation and vendor in predictable ways.

The adapter also reports features, a list of optional capabilities like shader-f16, timestamp-query, or depth-clip-control. Which subset is present depends on the actual GPU and driver version. Put the limits and the feature list together and you get a fairly narrow fingerprint before a single pixel gets rendered. A script doesn’t need to draw anything to start narrowing down what machine it’s talking to. It just has to call requestAdapter() and read the object back.

Timing is the harder problem

Beyond the static info, WebGPU supports timestamp queries and lets pages run compute shaders and measure how long dispatches take. Different GPUs, even ones that report similar vendor strings, finish the same compute workload in different amounts of time because the underlying silicon and driver scheduling are different.

This matters because timing is much harder to spoof than a string field. You can override what requestAdapterInfo() returns in a browser’s JS environment fairly easily, that’s just intercepting a function call. You can’t as easily fake how long a real GPU takes to churn through a shader workload, because the actual computation is happening on actual silicon. If a page runs a small benchmark and the timing profile doesn’t match what the reported adapter claims to be, that’s a mismatch a detection script can flag, even if it never says explicitly what it caught.

Cross-checking against everything else

None of this works in isolation, and that’s the part worth understanding if you’re evaluating a tool. Detection scripts don’t look at WebGPU output and make a decision on the spot. They check it against:

  • The WebGL renderer and vendor strings, which should describe the same physical GPU
  • The user agent and platform claims (a “Windows 11, RTX-class GPU” profile should produce Windows/RTX-shaped adapter limits, not something else)
  • Screen and device pixel ratio, which correlate loosely with real hardware classes
  • Whether WebGPU is even available at all, given the claimed browser version

A spoofed profile that changes the WebGL renderer string but leaves WebGPU’s adapter info at its real value, or vice versa, creates an inconsistency between two APIs that are supposed to be describing the same physical device. That kind of cross-API mismatch is exactly the pattern fingerprinting systems are built to catch, because a real browser running on real hardware doesn’t produce it.

Why disabling WebGPU isn’t a free pass

The obvious move for a lot of anti-detect setups is to just turn WebGPU off or leave navigator.gpu undefined. That removes the leak, but it creates a different signal: a browser claiming to be a current version of Chrome or Edge on desktop, where WebGPU has been enabled by default for a while now, that suddenly has no navigator.gpu object at all is itself unusual. A detection script that checks “does this browser support the APIs it should support given what it claims to be” will flag the absence just as easily as it flags an inconsistent value.

This is the same trap that’s shown up with other fingerprint surfaces over the years. Blunt removal of a signal doesn’t hide you, it just swaps one anomaly for another, and depending on how thorough the checking script is, the second anomaly can be easier to catch than the first.

How anti-detect browsers are approaching it

The tools in this category, Multilogin, GoLogin, Kameleo, AdsPower, Dolphin Anty, and similar, generally take one of three approaches to a new GPU-adjacent API: pass it through untouched, override the returned values to match a target profile, or block it outright. WebGPU is new enough, and exposes deep enough hardware detail, that doing the override approach well is genuinely harder than it was for WebGL. You’d need the adapter info, the limits, the feature list, and the timing behavior to all cohere as one physical device, and the timing part in particular isn’t something you can just template from a JSON profile, because it depends on what’s actually computing the shader.

I haven’t run a structured side by side across these tools specifically on WebGPU consistency, so I’m not going to hand out a verdict here. What I’d tell anyone testing this themselves: don’t trust a “GPU spoofing” checkbox at face value. Open dev tools, call navigator.gpu.requestAdapter() yourself, log the info and limits, and compare it against what the same profile’s WebGL renderer string claims. If they describe two different GPUs, that’s your answer regardless of what the settings panel says.

What this means day to day

WebGPU doesn’t replace canvas, WebGL, audio, or font fingerprinting. It sits alongside them as one more data source a detection system can fold into a device confidence score. No single signal here, including WebGPU, is what gets an account flagged on its own in most systems. It’s the aggregate, and internal consistency across all of it, that platforms weigh. Anti-detect browsers, including good ones, reduce specific known signals; none of them make an account unbannable, and how a profile behaves over time still matters more than any one fingerprint check.

If you’re building or maintaining browser profiles for multi-account work, the practical takeaway is to actually look at what your tool reports through navigator.gpu rather than assuming a general anti-detect feature set covers it. The API is new, it’s more revealing than what came before it, and it’s still catching a lot of setups by surprise.

We cover fingerprinting mechanics and hands-on anti-detect browser testing like this regularly. Check out more breakdowns on the Anti-Detect Review home page.

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

need infra for this today?