WebGL Fingerprinting: How Your GPU Identifies You (and Why Consistency Matters)

10 min read

Open your browser's console, ask it what graphics card it has, and it will tell you. It tells every page you visit, too, without a permission prompt.

That's WebGL fingerprinting. It's not as famous as canvas fingerprinting, but it carries more detail than most people expect: a GPU name, a list of hardware limits and a set of supported extensions, all of which have to agree with each other for the browser to make sense.

This tutorial breaks down how WebGL fingerprinting works, what a page can read, how fingerprinting libraries check the values against each other, and why a browser profile's GPU values need to be generated together. It's written for privacy-minded users, QA engineers and site owners who want to know what their own pages could learn about a visitor. If you run several accounts, the platform's rules are a separate question from any of this; the Amazon multi-seller post covers what Amazon allows, for example.

What We're Building

By the end of this, you'll understand how websites extract GPU information through WebGL, which parameters add to a fingerprint, and why values that contradict each other make a browser more distinctive, not less.

We'll use public fingerprint viewers to see what a browser reports.

Prerequisites

  • Basic understanding of browser fingerprinting concepts (if you're new, start with our multi-account browser myths debunked post)
  • A browser with a dev console. If you want separate profiles to compare, a multi-account browser such as JustBrowser (7-day trial, card required, includes everything)
  • A viewer site like browserleaks.com open in another tab

Step 1: Understanding What WebGL Exposes

Open your browser's dev console and paste this:

const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
console.log('Vendor:', gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL));
console.log('Renderer:', gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL));

You'll see something like:

Vendor: Google Inc. (NVIDIA)
Renderer: ANGLE (NVIDIA, NVIDIA GeForce RTX 3080, OpenGL 4.5)

That's your GPU, exposed to every website you visit. There is no permissions dialog and no user consent step, which makes it unlike cookies.

The WEBGL_debug_renderer_info extension is widely supported. Sites query it, hash the result, and store it as part of a fingerprint. On its own, a renderer string is shared by everyone with that GPU; combined with other signals, it narrows a visitor down quickly.

But the renderer string is just the start. WebGL also exposes dozens of capability parameters that vary by GPU.

Step 2: The Parameter Fingerprint

Beyond the renderer string, websites query WebGL parameters that reveal hardware capabilities:

// These values can differ by GPU and graphics backend
gl.getParameter(gl.MAX_TEXTURE_SIZE);           // e.g., 16384
gl.getParameter(gl.MAX_VERTEX_ATTRIBS);         // e.g., 16
gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS); // e.g., 4096
gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);      // e.g., 16384

// Shader precision formats — this one's sneaky
const format = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT);
console.log(format.precision, format.rangeMin, format.rangeMax);

// And the extension list
console.log(gl.getSupportedExtensions());

A high-end desktop card and an integrated laptop chip can report different limits, different shader precision and different extension support. The combination is more distinctive than any single value.

Here's why this matters: if the renderer string names an integrated laptop GPU but the parameters and extensions are a high-end card's, the browser describes an impossible machine. Fingerprinting libraries check for exactly these contradictions.

Step 3: Why Hand-Edited GPU Settings Contradict Themselves

This mistake is common. Someone changes the GPU string in a browser or extension, leaves the parameters alone, and ends up with a configuration that contradicts itself.

The three ways a manual GPU override goes wrong:

1. Parameter mismatch. The renderer claims one GPU, but a capability value is one that GPU can't produce. The values contradict each other.

2. Impossible vendor/renderer combos. Renderer says "Apple M2" but vendor says "Google Inc. (NVIDIA)". Browsers that use ANGLE wrap the real vendor and renderer in a specific format. Getting this wrong is an obvious mismatch.

3. Extension inconsistency. The claimed GPU doesn't support certain WebGL extensions, but the browser reports those extensions as available anyway. FingerprintJS-style checks compare this.

The irony: a hand-edited configuration that contradicts itself is more distinctive than the real hardware would have been. Changing one string doesn't hide a GPU; it creates a rare combination.

Step 4: How Real GPUs Report Themselves

Real browsers report GPUs in predictable formats, which is what makes a contradiction easy to see.

ANGLE on Windows. On Windows, Chrome uses ANGLE to translate WebGL to DirectX, and the renderer string looks like:

ANGLE (NVIDIA, NVIDIA GeForce RTX 3060, D3D11)

Or for an OpenGL backend:

ANGLE (NVIDIA, NVIDIA GeForce RTX 3060, OpenGL 4.5)

Intel integrated looks like:

ANGLE (Intel, Intel(R) UHD Graphics 620, D3D11)

The exact format depends on the operating system and graphics backend, so when you compare a profile against real hardware, check what a real machine of that type reports rather than assuming.

Limits come from the hardware and the driver. Values like the maximum texture size and the aliased line width range aren't arbitrary; they're limits the GPU, its driver and the graphics backend report together. That's why they can't be changed one at a time and still make sense.

JustBrowser generates the WebGL vendor, renderer and extension list from real GPU population data (updated remotely between releases), so the renderer string and extension set stay consistent with each other, and the engine renders them at the C++ level rather than through a script override. Each profile keeps its own consistent configuration, so a profile you share with a teammate reports the same machine every time it launches.

Step 5: Checking What a Browser Reports

To see what a browser or profile reports, use a public viewer.

Viewers such as browserleaks.com show the WebGL section in detail. Look at:

  • The WebGL vendor/renderer
  • The parameter values and extension list
  • Any note about inconsistencies between the values

FingerprintJS's open-source library at fingerprint.com lets you read the same signals programmatically, which is useful if you want to see what your own site could learn about its visitors.

What you're looking for is a set of values that agree with each other. A public viewer can show you an inconsistency that exists, but it can't tell you what a particular site's own checks will make of a browser, since large platforms run private checks. Treat it as a way to understand your own browser, not as a verdict.

Common Errors and How to Fix Them

Error: "WebGL vendor/renderer mismatch" in a fingerprint viewer

The vendor string doesn't match the expected format for the renderer. This usually means a GPU string was edited by hand. Fix: undo the manual edit. In JustBrowser, regenerate the profile's fingerprint so the vendor, renderer and extensions are produced together again.

Error: "Parameter inconsistency detected"

A capability value or shader precision doesn't match what's expected for the reported GPU. Fix: the same — don't patch individual values; regenerate the configuration as a whole.

Error: "Extension support mismatch"

The browser reports extensions the "GPU" shouldn't support, or is missing ones it should have. This is tedious to fix manually and easy to get wrong. Fix: use a browser that generates the extension list together with the GPU, or leave the values as your real hardware reports them.

Error: A site still challenges the session

Public viewers show only part of what a site reads, and a challenge is the site's decision about the session, not a fingerprint puzzle to solve. If it's your own account, complete the verification the site offers; if a platform has restricted an account, use its appeal route. For running many client accounts the way platforms allow, see the guide to managing many client ad accounts.

Entropy and Fingerprinting: The Math

Quick detour into why this matters quantitatively.

Browser fingerprinting works by combining signals until the combination is unique. Each signal contributes "bits of entropy" — roughly, how many yes/no questions it takes to identify you.

WebGL contributes through several parts:

  • Renderer string: there are thousands of GPU models in use
  • Parameter values: more parameters queried, more detail
  • Shader precision formats
  • Extension support

For context, about 33 bits is enough to tell every person on Earth apart (2 to the 33rd power is roughly 8.6 billion). A full browser fingerprint (canvas + WebGL + fonts + audio + timezone + screen + Client Hints) combines many signals, and WebGL is a significant chunk of that.

The consequence for privacy: the more common a configuration is, the more people share it, and the less it identifies anyone. An inconsistent configuration does the opposite, because it puts a browser in a very small group of browsers reporting impossible hardware.

Next Steps

WebGL is one piece of the fingerprint stack. If you run separate profiles for work you're allowed to do (client accounts with permission, QA, ad verification), each profile needs the whole surface to agree:

  • Canvas fingerprinting — the same principle applies: consistency over randomization
  • AudioContext — harder to keep consistent than WebGL, often overlooked
  • Client Hints — the newer API that is easy to get wrong in tools that override values with JavaScript
  • Proxy configuration — a profile's location, timezone and language should agree with its proxy

For the wider operational picture, check ClickzProtect if you're running ad accounts (click fraud eats budgets) and JustAnalytics for privacy-first conversion tracking that doesn't feed data back to the ad platforms. If you're checking geo-specific rendering for ad verification workflows, consistent GPU parameters across your profiles keep the comparison fair.

More fingerprinting deep-dives on the JustBrowser blog. If you want to see these signals across separate profiles, JustBrowser's 7-day trial (card required) includes profiles with generated GPU parameters — enough to look at every concept here, and you can cancel inside the week if it isn't for you.

Or check your current browser first.

Frequently Asked Questions

How much does WebGL contribute to a browser fingerprint?

A meaningful share. The renderer and vendor strings name the GPU, and the capability parameters, shader precision formats and extension list add more detail. On its own a GPU model is shared by many people, but combined with fonts, screen, timezone, canvas and audio it narrows a visitor down quickly. For scale: about 33 bits of information is enough to tell every person on Earth apart, so each signal that adds even a few bits matters.

Can websites tell when WebGL values have been overridden?

Often, if the values are inconsistent. A browser reporting an integrated laptop GPU alongside capabilities only a high-end card has contradicts itself, and fingerprinting libraries such as FingerprintJS look for contradictions like that. It's why a profile's WebGL values need to be generated together, not edited one string at a time.

What's the difference between WEBGL_debug_renderer_info and parameter fingerprinting?

WEBGL_debug_renderer_info exposes the unmasked vendor and renderer strings directly — the human-readable GPU name. Parameter fingerprinting queries capabilities like MAX_TEXTURE_SIZE, MAX_VERTEX_ATTRIBS, and shader precision formats. Both are used for identification. Blocking the debug extension hides the GPU name but still leaks the parameter profile, which is often distinctive on its own.

Should I block WebGL entirely to avoid fingerprinting?

Usually not. Few browsers have WebGL disabled, so turning it off is itself unusual, and many sites rely on it. For most people the better approach is a browser that reports one consistent configuration, rather than blocking or randomising values.


Try JustBrowser

A multi-account browser for teams, built on a custom Chromium engine — not extension-based. Native C++ engine patches at the canvas / WebGL / audio / font / screen layer provide 40+ identity parameters, and each profile keeps its own cookies, storage and proxy. Local 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.

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

Tags
  • webgl-fingerprinting
  • gpu-detection
  • browser-fingerprinting
  • multi-account-browser
  • creepjs-test

Ready to manage multiple accounts?

Seven days free, then $9.99/month — one plan, everything included.

We'd like to use Google Analytics, a Google service, to understand how our website is used. It sets two cookies in your browser and runs only if you click Accept. You can change your choice at any time with Cookie settings. Cookie Policy

Sign-in cookies and the cookie that remembers this choice are always on; the website needs them to work.

Google Analytics, a Google service, helps us understand how our website is used. It sets two cookies, _ga and _ga_TVZHQ99TZW. It is now onoff in this browser. If your browser sends a Global Privacy Control or Do Not Track signal, it stays off. Cookie Policy