WebRTC ICE Fingerprinting: What Candidates and Media Tracks Reveal
Two browser profiles can use different proxies, different cookies, different everything, and still show the same ICE candidate ordering and the same media device list reporting a "Blue Yeti" and a "Logitech C920."
At that point the IP isn't what stands out. The RTC stack is.
Most WebRTC content covers the obvious problem: a real IP slipping past a proxy through STUN requests. That's well-trodden ground, and a clean browserleaks.com leak result only answers that one question. It says nothing about the structure of the candidates or the device list a page can read.
This tutorial walks through how ICE candidates and media tracks work as signals, how to inspect them in your own profiles, and what you can and can't change from the browser's side. It also covers privacy and QA cases where knowing this matters.
What We're Building
By the end you'll understand three surfaces WebRTC exposes beyond the IP leak: ICE candidate structure, mDNS host candidate patterns, and media device enumeration. You'll know how to inspect each one, and how to check that each profile on your machine reports what you expect.
We'll use browserleaks.com/webrtc and CreepJS purely as viewers of what a page can read.
Prerequisites
- Basic understanding of WebRTC concepts (STUN, TURN, ICE; if these are unfamiliar, spend 10 minutes on the MDN WebRTC docs)
- A multi-account browser so you can compare several profiles side by side (JustBrowser has a seven-day trial, card required)
- A test environment: browserleaks.com/webrtc open in one tab, CreepJS in another
- To test media device enumeration: a webcam or mic attached (or virtual devices configured)
Step 1: Understanding ICE Candidate Structure
When a WebRTC connection initialises, the browser gathers "ICE candidates", the potential network paths for the connection. Open your browser console and paste this:
const pc = new RTCPeerConnection({
iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
});
pc.createDataChannel("test");
pc.createOffer().then(offer => pc.setLocalDescription(offer));
pc.onicecandidate = (e) => {
if (e.candidate) console.log(e.candidate.candidate);
};
You'll see output like:
candidate:842163049 1 udp 1677729535 192.168.1.42 54321 typ host generation 0
candidate:1234567890 1 udp 1685921535 a1b2c3d4.local 54322 typ host generation 0
candidate:2345678901 1 udp 100401151 203.0.113.45 54323 typ srflx raddr 192.168.1.42 rport 54321 generation 0
Three candidate types show up:
- host: your local IP (or its mDNS-obfuscated version)
- srflx: server-reflexive, your public IP as seen by the STUN server
- relay: TURN relay candidates (if configured)
The signal isn't just the IPs. It's the structure: how many candidates, their priority values (that big number), the order they appear, whether IPv6 candidates exist, whether host candidates use mDNS.
Different systems produce different patterns. A laptop on WiFi generates different candidates than a desktop on Ethernet. A VPN changes the pattern. Multiple network interfaces change it.
The pattern is fairly stable across sessions on the same machine.
Step 2: Why mDNS Obfuscation Isn't the Whole Story
Chrome and Firefox implemented mDNS obfuscation around 2020 to address the local IP leak. Instead of exposing your real local IP (192.168.1.42), the browser generates a random UUID:
candidate:1234567890 1 udp 1685921535 a1b2c3d4.local 54322 typ host generation 0
That .local address can't be resolved by remote servers, so your internal IP stays hidden. Problem solved?
Not quite.
Even with the UUID randomised, the surrounding structure remains:
- Number of host candidates (depends on network interfaces)
- Priority values (computed from network interface properties)
- Presence of IPv6 candidates
- Order of candidate generation
Anyone hashing that structure gets a value tied to your machine's network setup. Two profiles on one machine are likely to produce similar values for the simple reason that they share one network stack. That's worth knowing when you test.
Step 3: The Media Device Enumeration Surface
Here's the less obvious one. Run this:
navigator.mediaDevices.enumerateDevices().then(devices => {
devices.forEach(d => console.log(d.kind, d.label, d.deviceId));
});
If you've granted camera/mic permission to the page, you'll see something like:
videoinput HD Pro Webcam C920 abc123def456...
audioinput Blue Yeti aabbccdd...
audiooutput Speakers (Realtek High Definition Audio) eeff0011...
Those labels are hardware identifiers, and the combination is quite distinctive. Most people don't share the same webcam, microphone and speaker setup.
Without permission, depending on the browser, the API can still reveal:
- Device count per category (1 camera, 2 microphones, 3 audio outputs)
- Device IDs, where exposed (hashed, but consistent within an origin)
Device IDs are origin-scoped, so they differ between sites. The counts and kinds don't. They're the same on every site you visit.
None of this needs a video call. A page can create a silent RTCPeerConnection, gather candidates and enumerate devices without a visible prompt. If you run multi-account work where each profile belongs to a separate client or role, it's worth knowing what a page can read.
Step 4: Inspecting Your Current Setup
Before changing anything, look at what's exposed.
BrowserLeaks WebRTC Test (browserleaks.com/webrtc):
- Check the "Local IP Address" section, which catches the classic IP leak
- Look at the ICE Candidates table and compare it across profiles
- Note the candidate types and ordering
CreepJS (abrahamjuliot.github.io/creepjs):
- Scroll to the Media Devices section
- Check whether device labels or counts appear
- Look at the WebRTC section for candidate data
Manual check across profiles:
- Open the same test in two different profiles
- Copy the full ICE candidate lists
- Compare them line by line
If the structures match, the two profiles share a WebRTC signature that comes from the host machine. That's expected: they run on one computer. It matters if you assumed each profile was fully separate at this layer.
Step 5: What You Can Control
Be realistic about the options. Some are browser settings, some depend on the engine, and some aren't available to you at all.
Option 1: Disable WebRTC entirely
The blunt option. In Firefox, set media.peerconnection.enabled to false. Chromium-based browsers don't offer a simple built-in switch, so people usually reach for an extension or a policy. This breaks:
- Google Meet
- Discord voice
- Any in-browser video calls
If your use case is scraping public data or QA on pages that don't need WebRTC, it's the simplest approach. The catch: a browser with WebRTC switched off is itself an unusual configuration, so you've swapped one signal for another.
Option 2: Restrict what WebRTC exposes
Browsers have policy-level settings that limit which interfaces WebRTC will use, and a TURN-only setup (relay candidates only) shrinks what a page sees to the relay's details. You need a TURN server you control, and latency goes up. Check in your own browser's documentation which of these it supports; this post doesn't claim any particular setting exists in JustBrowser.
Option 3: Use a multi-account browser for profile isolation
JustBrowser is a multi-account browser for teams on a custom Chromium engine, with native C++ patches at the canvas / WebGL / audio / font / screen layer and 40+ identity parameters. Each profile keeps its own cookies, storage, proxy and identity parameters. Even so, inspect ICE candidates and media devices per profile with the tests from Steps 1-4. Don't assume they differ between profiles just because cookies and storage are separate.
Option 4: Mind your hardware
For media devices, the practical lever is on your side: unplug hardware you don't need, don't grant camera or microphone permission to pages that have no reason to ask, and use per-site permission prompts. Without permission you still leak counts, but not labels.
My opinion: for most teams, the right default is to stop treating WebRTC as a separate battle and decide per profile whether it needs WebRTC at all. A profile for managing client ad accounts rarely needs a camera.
Step 6: Verifying What You Chose
After adjusting a profile:
-
Re-run the BrowserLeaks WebRTC test
- Candidates should match your intent (relay-only, restricted, or WebRTC off)
- No real local IPs should appear
-
Compare two profiles
- Run the ICE gathering script from Step 1 in both
- Note which values differ and which match. Matching values from the same host are normal.
-
Check media device exposure
- Run enumerateDevices() before and after granting permission
- Confirm labels only appear when you've allowed them
-
CreepJS inspection
- Read the WebRTC section and check the values make sense together
- Treat it as a way to see what a page can read, not a score to chase
Common Errors and How to Fix Them
Error: ICE candidates still show a real local IP
Your restriction isn't taking effect. Some tools offer a relay-only option that only filters results in JavaScript. Fix: confirm the browser is actually using your TURN server and that no host candidates appear in the test.
Error: mDNS addresses look the same across profiles
Profiles on one machine share an underlying network stack, and the address format is determined by the engine. Fix: check each profile's results individually before assuming they differ, and consider relay-only mode if host candidates matter to you.
Error: Media device enumeration returns real hardware
That's expected whenever a page has permission. Fix: don't grant camera or microphone access unless the profile needs it.
Error: Candidate priority values look odd
Priority values come from network interface types and preferences, so unusual values often mean an unusual network setup (VPN, virtual adapters). Fix: check your network interfaces before blaming the browser.
Why Extensions Only Go So Far
Quick aside on architecture. (Skip to the FAQ if you don't care about the details.)
WebRTC lives in the browser engine. When you call new RTCPeerConnection(), native code in Chromium initialises the ICE agent, gathers candidates, and fires events to JavaScript.
Extensions work at the JavaScript layer. They can:
- Override the
RTCPeerConnectionconstructor - Filter candidates before
onicecandidatefires - Block
enumerateDevices()responses
They can't change how the engine generates candidates or computes their priorities. That's one reason JustBrowser is built on a custom Chromium engine instead of an extension. Whether a given RTC behaviour is configurable in the app is a separate question, and the answer is in the app, not in this post.
Next Steps
WebRTC is one piece of what a page can read. If you're setting up profiles for client accounts or automation, the rest matters too:
- WebGL — GPU rendering data, covered in our WebGL fingerprinting guide
- Canvas — the most-discussed vector, where consistency matters more than randomisation
- Audio — AudioContext output is subtle and often overlooked
- Fonts — system fonts vary widely across real populations
For proxy configuration, keep any TURN server in the same region as your HTTP proxy. A proxy in Frankfurt with a relay in Singapore adds latency and puts the profile in two places at once. Our proxy setup guide covers keeping a profile's location settings consistent.
If you're automating your own workflows, see our Playwright and Puppeteer integration for headless launch configuration. For ad verification across geos, see our ad verification workflow.
For privacy-first analytics on your own sites, JustAnalytics is the companion product.
Frequently Asked Questions
What is WebRTC ICE candidate fingerprinting?
ICE candidate fingerprinting uses the order, types, and properties of ICE candidates generated during WebRTC connection setup to recognise a browser. Even with IP masking enabled, the pattern of candidate types (host, srflx, relay) and their priority values forms a signal. Different network configurations produce different candidate orderings, and this pattern tends to persist across sessions.
Can mDNS obfuscation prevent WebRTC fingerprinting?
Partially. mDNS obfuscation replaces local IP addresses with random UUIDs like 'a1b2c3d4.local', hiding your internal network topology. But the candidate structure itself (how many candidates, their priority values, transport protocols, and ordering) still varies by system. mDNS addresses the IP leak, not the structural signal.
How do media device labels contribute to browser fingerprinting?
navigator.mediaDevices.enumerateDevices() returns labels like 'HD Pro Webcam C920' and 'Blue Yeti Microphone' when permission is granted. The combination of labels is quite distinctive because most people own different hardware. Even without permission, some browsers still expose the count and types of devices (videoinput, audioinput, audiooutput), which adds entropy.
Do extensions control how WebRTC candidates are generated?
Generally, no. Extensions can wrap or block JavaScript APIs, but the browser's native RTC stack gathers ICE candidates below that layer. An extension can filter what reaches a page; it does not change how the engine builds candidates.
Try JustBrowser
A multi-account browser for teams on a custom Chromium engine — not extension-based. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, with 40+ identity parameters, patched on every upstream Chromium release. REST API for Playwright, Puppeteer, Selenium. 7-day free trial, card required — then $9.99/month or $99.99/year, unlimited profiles, free team seats.
Get started → · How it differs from other multi-account browsers
Ready to manage multiple accounts?
Seven days free, then $9.99/month — one plan, everything included.