Audio, Font, and Hardware Fingerprinting: The Three Signals Most Guides Skip
Canvas and WebGL get most of the attention in browser fingerprinting write-ups. Audio, font and hardware signals get far less, yet they are the ones that tie a browser to a specific machine across sessions without cookies.
This post is for people who build or defend sites, test across devices, or care about privacy: how each of the three signals works, how to see what your own browser exposes, and what a consistent browser profile should present.
Check your own fingerprint first. We built a public checker at justbrowser.app/fingerprint-checker that runs client-side, with no signup. It grades what it claims rather than guessing: WebRTC candidates are compared against your public IP, and the IP's location is graded on whether its UTC offset actually agrees with your browser's timezone. Worth running before you read the rest of this, so the signals below have your numbers attached to them.
Why These Three Signals Matter
Canvas and WebGL are well understood and widely tested, including by tools such as BrowserLeaks. AudioContext, font enumeration and the hardware APIs get less attention. They are harder to control at the JavaScript level because they depend on the browser engine itself, which is why changing them takes work inside the engine rather than a wrapper that intercepts API calls. (If you run analytics on your own site, such as privacy-first analytics with JustAnalytics, it's worth knowing which of these signals your scripts read.)
For teams doing ad verification across geos, these signals decide whether a test profile behaves like one consistent device, so the test shows what that kind of visitor would see. Bot-detection tools such as ClickzProtect read visitor signals from the other side, to spot bot clicks on paid traffic.
AudioContext: The Fingerprint You Can't Hear
Here is what happens when a page implements audio fingerprinting:
const audioContext = new (window.AudioContext || window.webkitAudioContext)();
const oscillator = audioContext.createOscillator();
const analyser = audioContext.createAnalyser();
const gainNode = audioContext.createGain();
const scriptProcessor = audioContext.createScriptProcessor(4096, 1, 1);
oscillator.type = 'triangle';
oscillator.frequency.setValueAtTime(10000, audioContext.currentTime);
gainNode.gain.setValueAtTime(0, audioContext.currentTime);
oscillator.connect(analyser);
analyser.connect(scriptProcessor);
scriptProcessor.connect(gainNode);
gainNode.connect(audioContext.destination);
oscillator.start(0);
scriptProcessor.onaudioprocess = function(event) {
const output = event.inputBuffer.getChannelData(0);
// Hash the output buffer — this varies by device
const hash = hashFunction(output.slice(4500, 5000));
console.log('Audio fingerprint:', hash);
oscillator.stop();
};
No sound plays, because the oscillator runs through a gain node set to zero. But the processing happens, and the output waveform differs depending on the audio stack. The combination of audio hardware, drivers, sample rate handling and the browser's own audio code produces a result that differs between many devices.
Researchers have documented audio fingerprinting scripts running on real websites. The signal isn't unique on its own, but it is stable: the value doesn't change when you clear cookies or switch IP addresses, so it persists across sessions.
Two properties matter if you keep separate profiles on one machine, for privacy or for testing:
- It should differ between profiles. If twenty profiles all return the identical audio hash, they all show the same underlying audio stack, so a tracker that sees two of them can tell they share a machine, and twenty test "devices" are really one.
- It should be stable within a profile. A value that changes on every launch makes test results hard to compare, and real devices don't behave that way.
So the goal is a per-profile audio output that is different from other profiles, the same on every launch, and consistent with the device the profile presents. That has to be done in the engine: Chromium's audio code is C++ and cannot be patched from JavaScript. JustBrowser does it natively, giving each profile its own seeded audio output. That is one of the reasons it is built on a custom Chromium engine rather than a wrapper.
Font Fingerprinting: Measuring Text With measureText()
Open your browser console and paste this:
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
const fonts = ['Arial', 'Times New Roman', 'Comic Sans MS', 'Adobe Garamond Pro', 'Calibri', 'Menlo'];
ctx.font = '72px monospace';
const baseline = ctx.measureText('mmmmmmmmmmlli').width;
fonts.forEach(font => {
ctx.font = `72px '${font}', monospace`;
const width = ctx.measureText('mmmmmmmmmmlli').width;
console.log(font, width !== baseline ? 'INSTALLED' : 'NOT INSTALLED');
});
This is font enumeration. Sites do not get your font list directly, but they can measure text width. Different fonts produce different pixel widths for the same string, so by testing hundreds of font names against a monospace baseline, a script can work out which fonts are on your system.
Your font list reveals:
- Operating system: macOS ships with SF Pro and Menlo; Windows ships with Calibri and Segoe UI
- Locale: CJK fonts suggest Asian language users; Arabic fonts suggest Middle Eastern users
- Installed software: Adobe Creative Suite and Microsoft Office each install specific fonts
- Custom fonts: developers often install Fira Code or JetBrains Mono, which stand out
A font list usually says more about a machine than its audio output does, and like audio, it persists across sessions.
For a profile that presents a particular operating system, the font list has to agree with it. A profile claiming macOS that shows Calibri and Segoe UI is internally inconsistent, and measureText results must match the metrics of fonts that are actually rendered. Faking a list in JavaScript while measureText still returns monospace dimensions leaves exactly that inconsistency.
In JustBrowser, font handling is done in the engine. Each profile has its own font set that matches the platform identity it presents: a Windows profile sees the Windows set and a macOS profile sees the macOS set. The restriction is applied at the engine level, so CSS enumeration, the Font Access API and @font-face local() all follow it, and measureText stays consistent because metrics come from the font the profile actually renders with.
Hardware APIs: The Signals in Plain Sight
These are almost embarrassingly simple:
console.log('CPU cores:', navigator.hardwareConcurrency); // e.g., 8
console.log('Device memory:', navigator.deviceMemory); // e.g., 8 (GB)
Two lines expose your CPU core count and RAM to every website, with no permission prompt.
navigator.hardwareConcurrency was added so sites could spawn an appropriate number of Web Workers. But knowing someone has 4, 8 or 16 cores is also a useful fingerprint signal. Combined with deviceMemory (rounded to 0.25, 0.5, 1, 2, 4, or 8 GB to limit precision), it gives a rough hardware profile.
The Battery Status API goes further on browsers that still support it (mainly Chromium-based):
navigator.getBattery().then(battery => {
console.log('Level:', battery.level); // 0.87
console.log('Charging:', battery.charging); // true
console.log('Charging time:', battery.chargingTime); // 3240 seconds
console.log('Discharging time:', battery.dischargingTime); // Infinity
});
Exact battery level and charging state are a tracking signal: a level that drains from 87% to 85% across a session is something a script can correlate. Firefox removed the Battery API from web pages years ago; Chrome still has it.
Combined, hardwareConcurrency, deviceMemory and battery signals add a little more to a fingerprint. For a profile, what matters is that these values agree with each other and with the rest of the identity. 4 GB of RAM alongside 16 CPU cores is an unusual combination, and a profile presenting a recent MacBook should report core counts that fit that hardware. JustBrowser's 40+ identity parameters include the hardware values, set per profile so they stay consistent. It does not patch battery data. Mobile profiles present Chrome on Android's client hints, memory range and touch screen.
Why Consistency Beats Any Single Vector
It is tempting to focus on one signal at a time. The better view is consistency across all of them.
If a profile's canvas output says it is a MacBook Pro with an M3 chip, but its font list contains Windows-only fonts and hardwareConcurrency reports 4, the combination does not add up, even if each value looks reasonable alone. Sites that check for this treat the mismatch as a sign something is wrong, and so do tests you run on your own pages.
And the opposite case matters too. If you run twenty profiles for QA or client work and they all return the identical AudioContext output, they all expose the same underlying audio stack. Each profile should have its own.
What This Means for Your Setup
If you run several profiles, audit them against these signals specifically:
-
Check audio stability. Open the same profile twice on an audio fingerprint test. Does the hash match both times? Now try a different profile. Is the hash different?
-
Check font enumeration. Use BrowserLeaks or a similar tool. Does the font list match the operating system the profile presents? A profile presenting macOS should not show Calibri and Segoe UI.
-
Check hardware values. Open DevTools and read
navigator.hardwareConcurrencyandnavigator.deviceMemory. Do they differ between profiles where they should, and do they fit plausible hardware? -
Look at the full picture. Run the JustBrowser fingerprint checker and compare the rows. Any disagreement between values is worth fixing.
For teams running ad verification, these signals matter because the point is to see a page the way a visitor in a given geo and on a given device sees it. We covered the workflow in our ad verification guide. If you also buy traffic, ClickzProtect watches click quality on your own campaigns from the site side.
Where This Is Heading
Audio, font and hardware signals are documented in public research, and tools that collect them are widely available. The practical consequence is simple: values should be generated in the browser engine, and they should be consistent. You cannot patch AudioContext from JavaScript, and you cannot fix font isolation with an extension. These are engine-level choices, which is why JustBrowser is built on a custom Chromium engine with native C++ integration, patched on every upstream release.
More on fingerprint signals and testing on the JustBrowser blog. For a hands-on test, the JustBrowser trial runs seven days with nothing held back (card required): create a few profiles and compare their audio, font and hardware values with your current setup. If you run your own site's analytics with JustAnalytics, the same rule applies there: know what your scripts read. Whatever you use, stay within each platform's rules.
Frequently Asked Questions
How does AudioContext fingerprinting work?
AudioContext fingerprinting works by processing a silent audio signal through the Web Audio API and measuring the output waveform. Different combinations of audio hardware, drivers, and browser implementations produce subtly different oscillator and compressor outputs. The resulting waveform hash is consistent across sessions but varies between devices. It isn't unique on its own, but it adds to a fingerprint and survives clearing cookies.
Can websites detect my installed fonts without permission?
Yes. Websites enumerate fonts by measuring text width differences using canvas measureText(). A string rendered in Arial will have different pixel dimensions than the same string rendered in Times New Roman. By testing hundreds of font names and comparing widths against a baseline, sites can determine which fonts are installed on your system. This reveals your operating system, locale, and software (Adobe users have specific fonts, for example).
What hardware APIs leak fingerprint data?
navigator.hardwareConcurrency reveals your CPU core count. navigator.deviceMemory exposes your RAM (rounded to 0.25, 0.5, 1, 2, 4, or 8 GB). The Battery Status API (where still supported) exposes charging state and battery level. Combined, these signals give a rough hardware profile that adds to a fingerprint.
How does JustBrowser handle audio, font and hardware signals?
JustBrowser is a multi-account browser built on a custom Chromium engine with native C++ integration, not an extension. Each profile has its own audio output, its own font set matched to the operating system the profile presents, and hardware values that agree with each other. They are generated in the engine rather than patched in JavaScript, so the values stay consistent across sessions.
Try JustBrowser
A multi-account browser for teams, built on a custom Chromium engine with native C++ integration, not an extension. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, so 40+ identity parameters are genuine, not faked. Each profile keeps its own cookies, storage and proxy, and teammates can share profiles. 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
Ready to manage multiple accounts?
Seven days free, then $9.99/month — one plan, everything included.