Canvas WebGL And Audio Hashes: The Rendering Tests Behind Your Fingerprint
A page can draw a line of text you never see, turn the pixels into a 32 character string, and know your machine by that string the next time you visit. It takes a few milliseconds. No permission prompt appears. Nothing gets written to your disk. Canvas, WebGL and audio fingerprinting are the three rendering tests that sit underneath most of the device signals people talk about, and they’re the ones antidetect tools spend the most effort faking. This piece goes one level below the usual list of signals. It covers what each test actually draws or computes, why the result differs between machines, how a site reads a spoof out of the output, and what you should be looking at when a free checker hands you a hash and a percentage.
What a rendering test measures
The idea behind all three tests is the same. Ask the device to do a piece of work whose output depends on the hardware and software that performed it, then read the output back.
Drawing text onto a canvas goes through the operating system’s font rasteriser, the browser’s graphics library and often the GPU. Rendering a 3D scene through WebGL goes through the graphics driver and the card. Running an audio signal through the browser’s audio engine goes through floating point maths that different CPUs and builds round in slightly different ways. In every case the instructions are identical for every visitor. The result is almost identical. That “almost” is the whole signal.
A site doesn’t need to keep the full image or waveform. It hashes the output into a short string. Two machines that produce the same pixels produce the same hash. Change one pixel in a hundred thousand and the hash changes completely.
What matters for you is that these tests measure behaviour. A user agent string is a claim a browser makes about itself. A canvas hash is evidence of what the machine did when asked to draw. You can edit a claim in a settings panel. Changing the evidence means changing what the machine does, or intercepting the answer on its way back to the page, and both of those leave marks of their own.
That difference, claim versus evidence, runs through everything below. Most of the ways people get caught on these tests come from treating the evidence like a claim.
The canvas test step by step
Here’s roughly what a canvas fingerprinting script does. It creates a canvas element that’s never attached to the visible page. It sets a font, often a fallback chain ending in something generic, and draws a sentence that mixes Latin letters, punctuation and an emoji or two. It draws a few overlapping shapes in semi transparent colours, sometimes with a gradient, sometimes with a shadow blur. Then it calls one of the read back functions, either exporting the canvas as a PNG data string or pulling the raw pixel array, and hashes that.
Each of those choices is deliberate. Text brings in the font rasteriser, which handles anti aliasing and sub pixel positioning differently on each operating system. The emoji pulls in the system emoji font, which is different on every operating system and changes between OS versions. Semi transparent overlaps force the browser to blend colours, and blending is where small rounding differences show up. Shadow blur and gradients add more of the same.
The result is a picture that looks the same to a human on any machine. At the pixel level, the edge of each letter carries the fingerprint of the rasteriser that drew it, and the blended regions carry the graphics stack.
Canvas is stable. The same machine, with the same browser version and fonts, draws the same image every time. It isn’t unique on its own. Plenty of people with the same laptop model, OS version and browser build produce the same canvas hash, which is exactly why sites combine it with the other two tests and everything else.
Why the pixels differ between machines
It’s worth being concrete about where the variation comes from, because it tells you what a spoof has to get right.
Font rendering is the biggest source. Windows uses its own text rendering with ClearType style sub pixel smoothing on many setups. macOS has its own rasteriser and smoothing behaviour. Linux distributions vary with their font configuration. Android has its own again. Even on one operating system, a display scaling setting of 100 percent versus 150 percent changes how glyphs land on the pixel grid.
Then there’s the graphics path. Chromium draws canvas through its Skia library and may hand work to the GPU, depending on the canvas size and flags. GPU accelerated drawing and CPU drawing can produce slightly different anti aliasing on the same machine. Driver versions matter. So does the browser version, because the drawing library itself changes over time.
Installed fonts matter too. If the script asks for a font the machine doesn’t have, the browser falls back to another one, and the fallback choice depends on what’s installed.
So a canvas hash is a compressed summary of the operating system, its version, the display scaling, the browser build, the graphics path and the font set. That’s why it’s useful to a site. It’s also why you can’t pick a hash at random. A given hash only makes sense next to a particular combination of those things, and the site can see most of that combination through other signals.
WebGL has two halves
WebGL gives a site two different kinds of information, and checkers usually show them separately, so it helps to keep them apart.
The first half is the set of things the browser reports about the graphics stack. The best known is the unmasked vendor and renderer, exposed through a debug extension. On a Windows machine running Chrome this usually reads as an ANGLE string naming the card and the Direct3D backend. On a Mac with Apple silicon it reads as Apple’s own GPU naming. On a Linux server with no graphics card it may read as a software renderer. Beyond that name, WebGL reports dozens of parameters: maximum texture size, maximum viewport dimensions, supported extensions, shader precision formats, line width ranges and more. Those values come from the driver and the hardware limits of the card.
The second half is a rendering test, the 3D cousin of canvas. The script draws a small scene, perhaps a few triangles with gradients and lighting, reads the pixels back and hashes them. That hash reflects the GPU, the driver and the browser’s translation layer.
The two halves have to agree. A renderer string that names a particular mid range desktop card implies a certain set of parameter values and extensions, and a certain family of rendered output. Those pairings are fixed by how real drivers behave, and any large site sees the real combinations over and over in its own traffic. A renderer name with parameters from a different card, or a rendered hash that looks like a software renderer, is a contradiction even if every individual value looks normal.
The audio test
Audio fingerprinting surprises people because nothing plays. The script builds an offline audio context, which renders sound into a buffer as fast as the CPU can manage instead of sending it to speakers. It creates an oscillator, usually a triangle or sine wave at a fixed frequency, runs it through a dynamics compressor with fixed settings, and renders a second or so of output. Then it reads a slice of the samples and sums them, or hashes them.
The result is a floating point number, often printed with many decimal places. On one machine and browser build it’s the same every run. Across machines it varies in the later decimal places, because the compressor and the oscillator involve floating point operations whose rounding depends on the CPU’s instruction paths, the browser’s audio code and sometimes the operating system’s maths libraries.
Audio has less variety than canvas. Many machines with the same browser build and CPU family produce the same value, so it narrows the crowd less on its own. Its value to a site is that it’s independent. It goes through a different part of the machine from the drawing tests, so a spoof that handles canvas and WebGL but forgets audio leaves a value that belongs to the real host.
Some scripts also read properties of the live audio context, like its sample rate and reported latency. Those come from the audio hardware and output device settings. A profile claiming to be a phone that reports a desktop audio interface’s sample rate is contradicting itself in a place few people check.
Hashing and what the number means
When a checker shows you a canvas hash, it’s showing you a digest of the output, nothing more. The hash itself has no meaning. It can’t be decoded back into your GPU model. What gives it meaning is a database of other hashes.
A site that sees a lot of traffic builds exactly that database without trying. Every visit logs a canvas hash, a WebGL hash, an audio value and the claimed device details. Over time, each hash acquires a history: which renderer strings it appears with, which operating systems, which browser versions, how many distinct visitors.
This is the part most people miss. A common hash is not a problem, because common is what a real device looks like. A hash that’s never been seen before is information too. It might be a rare real machine. It might be a spoof. A hash that’s been seen many times but always alongside a different renderer string than the one you’re claiming is worse, because it looks like one device claiming to be another.
So the useful questions about your hash are relational. Does it change when it shouldn’t? Does it match what else the profile claims? Is it shared with other profiles you run that are supposed to be strangers? The raw string doesn’t answer any of those. Comparing it across reloads, restarts and profiles does.
How antidetect tools handle these tests
Antidetect browsers use a few broad approaches, and it helps to know which one your tool uses because each fails differently.
The first is noise injection. The tool lets the real rendering happen, then alters a small number of pixel values or sample values before the page sees them. The hash changes, so profiles on one machine stop sharing a hash. Done well, the noise is seeded per profile, so the same profile returns the same altered output every time. Done badly, the noise changes on every read.
The second is substitution. The tool reports a different WebGL vendor and renderer, a different parameter set, and returns canvas or WebGL output meant to match. This is much harder to do convincingly, because the output has to match what that claimed hardware would really produce.
The third is blocking. The read back call returns blank data, an error, or a uniform image. Privacy browsers sometimes do a version of this.
The fourth is the one that avoids the problem entirely: running each identity on hardware whose honest output is already distinct and plausible, such as separate real devices.
None of the first three is automatically wrong. Seeded noise is the most common default in current tools, and for many sites it does the job it’s meant to do, which is to stop your profiles from sharing a hash. Where each of them breaks is in the details the next section covers.
Why a spoofed hash can be worse than an honest one
An honest hash from a real machine has one property no spoof can fake cheaply: it’s consistent with everything else that machine reports, because the same machine produced all of it.
A spoof has to maintain that consistency by hand. Take a profile that claims a Windows laptop with an integrated Intel GPU. The renderer string says so. But the tool is running on a Mac, and the canvas noise sits on top of a macOS rendering of the test text. The noise changes the hash, yet the glyph edges still carry macOS smoothing. A site with enough data can tell that the hash belongs to a family seen with macOS, not Windows. The profile hasn’t hidden the Mac. It’s presented a Mac that says it’s a Windows laptop.
Or take a WebGL substitution that names a desktop card but returns rendered output that clusters with software rendering. That combination doesn’t exist on real hardware. Nobody’s real machine produces it.
Then there’s the unique hash problem. If a tool’s noise generates a hash nobody else on the internet has ever produced, and does that for every profile, each of those profiles becomes a rare device. Rare devices are easier to remember. A real person’s hash sits in a crowd of identical hardware.
An honest hash says “one ordinary machine.” A careless spoof says “a machine that doesn’t exist,” and that’s a stronger signal than simple reuse. Two profiles sharing an honest hash can be linked to each other. A profile with an impossible hash can be flagged on its own.
A worked example on one laptop
Picture a single MacBook running four profiles in an antidetect tool. This is a hypothetical, but it’s the most common setup there is, so it’s worth walking through.
Profile one is left on the tool’s defaults for the host, so it claims a Mac and presents Apple GPU naming. Canvas noise is seeded, so its hash is stable and distinct. That profile is in decent shape. Its rendering evidence is a Mac’s evidence with a small, consistent alteration, and it claims to be a Mac.
Profile two was set to claim Windows 10 with an Nvidia card because the operator thought Windows looked more common. The renderer string now names the Nvidia card through an ANGLE style label. But the WebGL parameters underneath come from the Apple GPU unless the tool replaces them all, and the canvas glyph smoothing is still macOS smoothing. Every one of those facts is available to a page. Profile two has more to hide than profile one, and fewer ways to hide it.
Profile three was set to randomise canvas on every read, because a forum post said randomising was safer. Its hash changes on every reload. Any script that draws twice sees two answers.
Profile four was created by cloning profile one to save time. It kept the same noise seed, so its canvas, WebGL and audio results match profile one’s exactly. The two profiles now share three rendering hashes, which is the precise link the tool was bought to prevent.
Only one of the four is set up the way the test would want. None of the others would look broken to the operator, because each one loads pages and logs in fine. The problems only show when you run the routine later in this piece.
The fix for each is short. Leave two on its honest host type. Switch three to a seeded mode. Give four a fresh seed, and check it with a second test page afterwards.
How sites catch noise and blocking
The detection side has cheap tools for this, and none of them are secret. They’re described in public research and in the source of open source fingerprinting libraries.
The simplest is drawing twice. The script renders the same image two times in a row and compares. Real hardware returns identical output. Per read noise returns two different answers, which proves something is interfering.
Another is drawing something with a known answer. Fill a small area with one solid colour and read it back. Every pixel should be exactly that colour on any machine. If a few pixels come back slightly off, the only explanation is noise injection.
A third is reading through different paths. Canvas output can come back as an exported image or a raw pixel array. It can be drawn in the main page, in an iframe, or in a web worker using an offscreen canvas. If the tool applies its alteration in one path and not another, the page gets two different answers for the same drawing, or gets the real host’s hash through the path the tool forgot.
A fourth is checking whether the functions themselves have been tampered with. Overriding a built in browser function in JavaScript can change how that function looks when inspected. Tools that patch at the engine level avoid this. Tools that patch with injected scripts often don’t.
Blocking gets caught by the simplest test of all: a blank canvas is not what any real device returns.
Reading a free checker
Free checkers like BrowserLeaks, CreepJS and similar pages will show you all three tests. Here’s how to read what they show without getting misled.
On the canvas page you’ll usually see a hash, a thumbnail of the drawn image and a uniqueness figure, something like “this signature was seen in a small percentage of visitors.” Ignore the uniqueness figure as a verdict. The checker’s visitors are people who test browsers, a crowd that skews heavily toward privacy tools and antidetect users. Being common or rare in that crowd tells you little about how you look to a mainstream site. The hash itself is what you’ll compare.
On the WebGL page, look at the unmasked vendor and renderer first. Ask whether it’s a plausible name for the device your profile claims. Then skim the parameters and extensions. You don’t need to memorise values. You need to notice when a phone profile shows desktop limits, or a named desktop card sits next to a software renderer’s extension list.
On the audio page you’ll see a long decimal number. Write down the digits it shows. Some pages also show the sample rate and channel count of the live audio context. Check those fit the device the profile claims, since a phone rarely reports the setup of a studio audio interface.
One more caution. Checkers change their test scripts, so a hash from one checker can’t be compared with a hash from another, or even with the same checker after it updates. Compare like with like, on the same page, on the same day.
CreepJS goes further and flags what it calls lies, where a property’s behaviour contradicts its claimed value. Treat those flags as leads to investigate, not proof you’ve failed. They’re built by someone looking for spoofing, which is exactly the right adversary to test against.
A test routine you can run in ten minutes
This is the check I’d run on any new profile before it touches a real account. It needs no special tools.
Open the profile and load a canvas test page. Note the hash. Reload the page. The hash should be identical. Close the browser completely and reopen the profile. Load the page again. Still identical. If the hash changes between reloads, the tool is using per read noise and any site that draws twice will see it.
Open a second profile on the same machine and load the same page. The hash should differ from the first. If it matches, your profiles share a canvas identity and can be linked on that alone.
Repeat both steps for the WebGL rendering hash and the audio value.
Then read the WebGL renderer string on each profile and compare it to the claimed operating system and device. A Windows profile should show a Windows style renderer string. A Mac profile should show a Mac style one. If your tool lets you pick a GPU, pick one that’s common for the claimed device and the claimed era, not the rarest or most powerful card on the list.
Finally, run a tougher checker like CreepJS and read any lie flags that mention canvas, WebGL, audio or the functions behind them.
Log what you find next to the profile’s name. The goal is a record that shows each profile stable over time and distinct from its neighbours.
Where the host machine leaks through
Every profile runs on something, and the host underneath shapes what the rendering tests can honestly produce.
A virtual server with no GPU is the classic trap. Browsers on such machines fall back to a software renderer, and the WebGL vendor and renderer strings say so plainly. Rendering is slow, parameters look like a software implementation, and the output clusters with other headless and server traffic. A tool can overwrite the renderer string, but the rendered output and the performance still come from software. If you’re running profiles on cloud servers without graphics hardware, assume the WebGL test is your weakest point.
Headless browsers, the kind automation frameworks start by default, often use the same software rendering path. That’s one of several reasons headless traffic is easy to spot.
Mixing hosts is the other trap. If some profiles run on a Windows desktop and others on a Mac, and a profile moves between them, its rendering evidence changes host underneath it. The profile claims the same device, but the rasteriser changed. Keeping a profile on the same host, or at least the same host type, keeps its evidence stable.
Driver and browser updates change output too. A graphics driver update on the host can shift canvas and WebGL results for every profile at once. That’s normal for a real person, since real hashes change when drivers update. It’s worth knowing so a sudden change across your whole fleet on one day doesn’t look like a mystery.
Where phones fit
On mobile, the equivalent tests run inside apps and mobile browsers against the phone’s own GPU and audio hardware. A real phone produces real phone output, consistent with its reported model, its GPU and its OS version, because it’s the device doing the work.
That’s the strongest reason operators move their most sensitive identities onto real devices. There’s nothing to spoof. Each handset’s rendering evidence is honest and belongs to one physical device. Two phones of the same model and OS version will often share hashes, which is how real phones look to a platform, since millions of people own that model.
Emulators are a different story. They render through the host’s graphics stack or a software renderer, and their GPU strings often name virtual or host hardware. A rendering test on an emulator tends to say “emulator” loudly, before any of the other emulator checks even run.
Rooted phones sit in between. The rendering is real hardware, so the hashes are honest, but the other integrity checks an app runs will usually notice the root. The rendering tests don’t settle the question for them either way.
A hosted real device avoids the emulator problem, but it isn’t a free pass. It still has to be paired with a network and behaviour that fit the same person. The rendering tests only answer one question: is this a real, ordinary device? A real phone answers yes honestly. Everything else about the account still has to hold up.
What to do with this
If you take one practical rule from all of this, make it consistency over cleverness. Each profile should produce the same canvas, WebGL and audio output every time it loads, that output should differ between profiles that are meant to be strangers, and it should be plausible for the device the profile claims to be.
Stop chasing a rare hash. A rare hash stands out. A believable, common one blends in.
Match the claimed device to the host where you can. A Windows profile on a Windows host has far less to fake than a Windows profile on a Mac. If you run profiles on servers without graphics hardware, treat WebGL as the likely leak and test it first.
Turn off any per read randomisation option your tool offers, if it offers one, and use the per profile seeded mode instead.
And know the limit. A good score on these three tests doesn’t protect an account. It removes one class of evidence that could link or flag it. The network the profile sits on, the behaviour of the account and the history attached to it still decide most outcomes, and no checker can show you the risk model a platform runs after you log in. I don’t know which exact rendering checks any given platform runs today, and nobody outside those platforms does either. What I can tell you is what the public test scripts do, and that a profile built to survive them is in far better shape than one that hasn’t been tested at all.
I run Singapore mobile proxy and cloud phone farms myself, with real handsets behind the phones, so the rendering evidence on the identities I care about most is honest because the device is real. If you want the rest of the device and network picture, along with the tools I actually use, start on the Multi Account Ops home page.
Get new guides and videos first — join the Telegram channel.