WebGPU Fingerprinting: The New GPU Detection Surface Replacing WebGL

You open the console in a browser profile, run a WebGL check, and it says "Intel UHD Graphics 620." Fine. Then you ask the newer API the same question and get a different GPU back.

That mismatch is the whole story of WebGPU fingerprinting. It is a second, richer description of the same graphics hardware, and a page that reads both can compare them. If the two disagree, the profile describes a machine that cannot exist.

This guide covers what WebGPU exposes that WebGL doesn't, why that matters for anyone running test, QA or verification profiles, and how to audit a profile yourself in a few minutes.

What We're Building

By the end you'll know:

What WebGPU exposes that WebGL doesn't (adapter info, features, limits)
How a script can use it to fingerprint a browser
How to compare WebGPU against WebGL in your own profiles
What to do when the two disagree

You'll query the API directly and read the output. Fifteen minutes, give or take.

Prerequisites

A current version of Chrome or another Chromium-based browser (WebGPU shipped to stable Chrome in May 2023)
A browser profile you want to audit, in JustBrowser or any other tool
Basic familiarity with fingerprinting concepts (the WebGL fingerprinting guide covers the fundamentals)
DevTools open

Step 1: See What WebGPU Exposes

Paste this into the console:

async function getWebGPUFingerprint() {
  if (!navigator.gpu) {
    console.log('WebGPU not supported');
    return;
  }

  const adapter = await navigator.gpu.requestAdapter();
  if (!adapter) {
    console.log('No adapter returned');
    return;
  }

  console.log('Adapter Info:', adapter.info);
  console.log('Features:', [...adapter.features]);

  const limits = {};
  for (const key in adapter.limits) {
    if (typeof adapter.limits[key] === 'number') limits[key] = adapter.limits[key];
  }
  console.log('Limits:', limits);
}

getWebGPUFingerprint();

The output has three parts, and the shape is what matters here, not any one value:

Adapter info: structured fields such as vendor, architecture and a device description.
Features: a list of discrete capability flags the adapter supports.
Limits: dozens of numeric values, for example maxTextureDimension2D and maxBindGroups.

WebGL's WEBGL_debug_renderer_info gives you one renderer string. WebGPU gives you a structured report. The architecture field is the clearest example: WebGL has no equivalent, so it's extra identifying detail.

Step 2: Why WebGPU Fingerprinting Detection Gets Its Own Check

WebGL and WebGPU are separate APIs on top of the same GPU. A script can call both in a few lines and compare the answers.

That is cheap for the script and awkward for the profile. Whatever tool builds the profile has to cover every place the GPU shows up, not just the one that has been fingerprinted for years. A tool that only adjusts WebGL values leaves the second report describing the real hardware.

How a given tool handles this depends on its architecture. Some tools work through JavaScript extensions; others operate at the engine level. The critical point: if a tool patches WebGL fingerprints but leaves WebGPU uncovered, a script that reads both will spot the difference. Treat your own audit (Step 4 below) as the source of truth for what your profile reports, rather than relying on any tool's claims, including any marketing claims about fingerprint consistency.

Step 3: Why the Entropy Matters

Every extra field a script can read narrows the pool of browsers that look like yours. Vendor, architecture, device description, the feature list and the limit values each carry some of that. Exact bit counts vary by population and by who is measuring, so be suspicious of any single figure.

The practical point is simpler. WebGPU adds more readable GPU detail than WebGL did, and the combination of the two is more distinctive than either alone. The audio and font fingerprinting deep-dive covers other surfaces that stack with it.

Step 4: Audit Your Profile

Step 4a: Read the WebGL renderer

const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debug = gl.getExtension('WEBGL_debug_renderer_info');
console.log('WebGL:', gl.getParameter(debug.UNMASKED_RENDERER_WEBGL));

Step 4b: Read the WebGPU adapter

const adapter = await navigator.gpu.requestAdapter();
console.log('WebGPU:', adapter.info.device, adapter.info.vendor, adapter.info.architecture);

Step 4c: Compare

Do the vendor and model describe the same GPU family? A profile showing an Intel integrated renderer in WebGL and an NVIDIA discrete card in WebGPU is internally inconsistent. Any script that reads both can see it.

Step 4d: Sanity-check features and limits

Some features and limit values belong to particular hardware classes. If a claimed integrated GPU reports capabilities you'd only expect from a recent discrete card, that deserves a second look. Check against a real device of the claimed type rather than guessing.

One more thing to check: an adapter that comes back null. That can be legitimate (no GPU, a driver issue, WebGPU disabled), but if the WebGL renderer claims a modern discrete GPU, the combination is odd.

Step 5: What to Do When They Disagree

Three options.

Option 1: Audit your profile directly. Run the Step 4 comparison yourself and look for alignment between WebGPU and WebGL output. If you're using JustBrowser, note that our engine patches the canvas, WebGL, audio, font and screen layers—the audit will show you whether the WebGPU output aligns with those other surfaces in your profile.

Option 2: Turn WebGPU off. Launching Chromium with the relevant feature disabled makes navigator.gpu undefined. It removes the mismatch, but a browser with no WebGPU is also a recognisable group in its own right, and a blank is not a neutral answer. We wouldn't call this a fix.

Option 3: Leave it. If no site you visit queries navigator.gpu, nothing happens. That is a bet on what others do, and it gets worse as more code reads the API.

Common Errors and How to Fix Them

WebGPU adapter info differs from the WebGL renderer

Cause: The profile configures one API but not the other.

Fix: Use a tool or configuration that covers both, then rerun the audit. Don't assume.

WebGPU reports a null adapter

Cause: WebGPU is unavailable: disabled, unsupported hardware or a driver problem.

Fix: Check whether that fits the GPU the profile claims. A modern discrete GPU in WebGL with no WebGPU adapter is inconsistent.

Feature flags don't match the claimed GPU

Cause: The feature list or limits come from different hardware than the renderer string describes.

Fix: Compare against a real machine of the claimed type. The Chromium GPU config files are a starting point for how Chromium treats GPU classes.

A public checker passes but your own test fails

Cause: A checker may not query WebGPU at all. Passing a test that never asks the question proves nothing about it.

Fix: Trust the console audit above for this surface.

Next Steps

WebGPU fingerprinting is one more surface in a growing fingerprint stack. Once you've verified your WebGPU consistency, look at:

TLS fingerprinting: the JA4 TLS fingerprint guide covers how to check yours.
Audio, font and hardware signals: see the audio, font and hardware fingerprinting breakdown.
Platform rules: the Facebook fingerprinting and Business Manager guide covers how Meta treats shared and managed accounts, including what its own tools allow.

For ad verification teams, ClickzProtect is a separate product for monitoring click quality on campaigns, and JustAnalytics covers privacy-respecting analytics.

WebGPU fingerprinting is still a young surface. A fifteen-minute console audit is cheaper than finding the mismatch later. Check your profiles.

Frequently Asked Questions

What makes WebGPU fingerprinting different from WebGL fingerprinting?

WebGPU exposes a different API surface. Instead of a renderer string from a debug extension, a script calls navigator.gpu.requestAdapter() and gets structured adapter info, a feature list and dozens of numeric limits. WebGL reports no architecture field, so WebGPU adds detail.

Do other browsers and tools handle WebGPU consistently?

It varies by tool and version, and we haven't verified any competitor's behaviour. Run the audit in Step 4 against your own profile instead of relying on a general claim.

Can I just disable WebGPU?

You can, but a browser without WebGPU is itself a distinct group, so it isn't a neutral choice. Whether consistent values or none is the better option depends on your use case.

How much does WebGPU add to a fingerprint?

It adds several readable fields beyond WebGL, and they combine with the rest of the stack. Published bit counts differ between studies, so treat any single number with caution.

Try JustBrowser

Native Chromium antidetect browser, not extension-based. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, so 40+ identity parameters are genuine. REST API + CDP for Playwright, Puppeteer, Selenium. $9.99/month or $99.99/year. 7-day free trial, card required: cancel any time in the seven days and you are not charged. Unlimited profiles, unlimited cloud sync, unlimited team seats.

Get started → · How it differs from Multilogin / GoLogin / AdsPower