WebGL and WebGPU fingerprinting identify a browser from what its 3D graphics interfaces reveal: the name of the graphics card and driver, dozens of numeric limits, the list of supported extensions and features, and the exact pixels of a small 3D drawing. Together they describe the graphics hardware underneath the browser in more detail than almost any other signal a page can read.
This guide goes through each of those four layers, explains why a renderer name that does not match the real hardware is easy to spot, sets out the choices a browser profile has, and shows how to see your own values in a minute.
Four layers a page can read
WebGL lets pages draw 3D graphics with the GPU. Any page can open a WebGL context on an invisible canvas, without permission and without showing anything. WebGPU is its newer successor, with closer access to modern graphics hardware. Both expose the same kinds of information.
1. Vendor and renderer names
By default WebGL reports deliberately vague names. The [WEBGL_debug_renderer_info](https://registry.khronos.org/webgl/extensions/WEBGL_debug_renderer_info/) extension then gives the "unmasked" vendor and renderer: the actual GPU, and often the graphics API and driver behind it. In browsers built on Chrome's graphics layer, the renderer string usually names that API too. A Mac reports Metal, a Windows PC reports Direct3D, and Linux reports OpenGL or Vulkan, so the string says not only which GPU you have but which operating system drives it.
2. Parameters and limits
A page can ask for about thirty numeric limits: the largest texture size, the number of texture units, the maximum viewport, the range of point and line sizes, shader precision. Each value is shared by many computers, but the combination is characteristic of a family of GPUs and drivers.
3. Extensions and features
getSupportedExtensions() returns the list of optional WebGL features the driver supports. WebGPU has its own list of features and limits on the adapter. Different vendors and driver versions support different sets, and the order and contents of the list are another strong hint.
4. The rendered image
Like a canvas fingerprint, a script can draw a small 3D scene with gradients and lighting, read the pixels back and hash them. Floating-point maths, shader compilers and anti-aliasing differ between GPUs and drivers, so the hash differs too.
WebGPU adapter information
With WebGPU, a page calls navigator.gpu.requestAdapter() and reads the adapter's [info](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/info): a vendor and an architecture name, along with the adapter's limits and features. Browsers keep this coarser than WebGL's unmasked strings, but it still names the GPU family. Because WebGPU is newer, it is also a place where a profile's WebGL settings and its WebGPU answers can disagree if they are not set together.
Why a fake renderer contradicts real hardware
The obvious way to "change your GPU" is to replace the renderer string, say from an Apple chip to a popular NVIDIA card. A script can do that in one line. But the string is only one of four layers, and the other three still come from the real hardware:
- The limits are still the Apple GPU's limits, which no NVIDIA card reports.
- The extension list is still Apple's.
- The rendered image is still drawn by the Apple GPU, so its hash matches Apple hardware.
- The graphics API in the string may now say Direct3D on a computer whose user agent and fonts say macOS, which cannot happen on a real device.
- WebGPU may still name the real vendor if only WebGL was changed.
Detection services have seen millions of real devices and know which renderer, limits and image hashes occur together. A renderer that claims one GPU while every other layer describes another is a stronger signal than an honest, common GPU would have been. Our free fingerprint test has a check for exactly this: Graphics vs operating system compares the graphics API in the renderer string with the operating system the browser claims.
Adding random noise to the WebGL image has the same problem as canvas noise: draw the scene twice, compare, and the two reads disagree, which real hardware never does.
The choices a browser profile has
For each profile, there are four sensible settings for the graphics surfaces, and each has a clear use:
| Setting | What a page reads | When it fits |
|---|---|---|
| Automatic | Labels chosen to fit the device the profile presents, drawn by the real GPU | Most profiles: the values agree with the rest of the fingerprint |
| Custom | Vendor and renderer labels you choose | When you need a specific label and know it fits the profile's device type |
| Real | Your computer's own names | When the profile should look exactly like this computer |
| WebGPU off | No WebGPU interface for that profile | When a task does not need WebGPU and you prefer to expose less |
Whatever you choose, the rule is the same: the labels should describe hardware that could plausibly produce the limits and images the page measures, on the operating system the profile presents.
How to check your own browser
- Open our free browser fingerprint test. It runs in your browser and sends nothing.
- In Graphics, read the WebGL vendor and renderer, the unmasked vendor and renderer, the WebGL limits hash, the WebGL image hash and whether WebGPU is present.
- In the consistency checks, look at Graphics vs operating system. A warning means the renderer names a graphics API that belongs to another operating system.
- Run the test in a second browser or profile and use Compare with the downloaded JSON to see which graphics readings changed and which stayed the same.
To see the raw values yourself, paste this into the developer console of any ordinary page:
const gl = document.createElement('canvas').getContext('webgl');
const dbg = gl.getExtension('WEBGL_debug_renderer_info');
console.log('renderer:', gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL));
console.log('max texture:', gl.getParameter(gl.MAX_TEXTURE_SIZE));
console.log('extensions:', gl.getSupportedExtensions().length);
const adapter = navigator.gpu && await navigator.gpu.requestAdapter();
console.log('webgpu:', adapter ? adapter.info : 'not available');Ask yourself whether the renderer, the texture limit and the WebGPU vendor all describe the same GPU, and whether that GPU fits the operating system in your user agent.
How Browz handles WebGL and WebGPU
Browz sets each profile's fingerprint in the browser engine, so no script is added to the page, and every layer above is answered by the same code. For graphics that means:
- Real graphics, chosen labels. WebGL and WebGPU draw with your real GPU, so the pictures they make are genuine. The vendor and renderer names a site reads can be automatic, set by you, or left real, per profile.
- WebGPU per profile. WebGPU can be switched off for a profile.
- Values chosen together. A profile is derived from a real device type and a seed, so its graphics names, platform, fonts and screen are chosen together and stay the same between sessions. The engines page shows Auto, Custom or Real for each surface, and Browz shows a coherence warning when a setting contradicts another.
- Noise only if you want it. WebGL noise is an option per profile, off by default.
Every protection is listed in plain words on the anti-detect page, with dated results from public test sites. On 13 November 2026, Browz 0.1.9 on macOS passed 15 of 15 consistency checks in our free test, including graphics against the operating system and stable readings, in a normal window and headless (our own result). To read every row of the test in order, see how to test your browser fingerprint, and for how all these values have to agree, fingerprint consistency checks.
Frequently asked questions
What is a WebGL fingerprint?
It is the set of facts WebGL reveals about your graphics hardware: the vendor and renderer names, numeric limits, supported extensions and the hash of a small 3D image the page draws. Combined, they identify a GPU and driver family, and they are one of the strongest parts of a browser fingerprint.
Can I hide my graphics card from websites?
Some browsers report generic names or block the debug extension, and you can turn WebGL off entirely, but many sites with maps, games or editors then break, and an unusual setup is itself a signal. Separate profiles whose graphics labels fit the device they present keep your activities apart without breaking pages.
Should I turn WebGPU off?
If the sites you use in a profile do not need it, turning it off exposes one interface less. Many sites do not use WebGPU yet. If a site needs it for graphics or machine-learning features, leave it on and keep its answers consistent with the profile's WebGL values.
Does a VPN change my WebGL fingerprint?
No. A VPN changes your network address, not your graphics card or driver. The WebGL and WebGPU values are the same with and without it.
Why does the renderer string mention ANGLE, Metal or Direct3D?
Browsers built on Chrome's graphics layer translate WebGL into the computer's native graphics API through a layer called ANGLE, and the renderer string includes that API. That is why the string reveals the operating system as well as the GPU, and why a mismatch with the user agent stands out.