A WebRTC leak test checks whether your browser reveals your real IP through WebRTC while a proxy or VPN is on. In our test through a proxy, Chromium showed the proxy IP to the page but reported our real IP to WebRTC. Setting the WebRTC policy to "disable non-proxied UDP" closed the leak.
Everything below was run on 20 November 2026 with Chromium 149 driven by Playwright, through QuanticData Residential Basic and Mobile proxies, from an Italian broadband line. IPs are masked.
Why WebRTC can go around a proxy
WebRTC is the browser feature behind video calls and peer-to-peer transfers. To connect two browsers, it asks a STUN server "what is my public address?" over UDP. An HTTP proxy, or a SOCKS5 proxy set in the browser, carries the page's requests; that UDP request goes out on your own connection and comes back with your own address. Any page can start this with a few lines of JavaScript and read the answer, so it can compare the IP that loaded the page with the IP that WebRTC found.
Run the WebRTC leak test yourself
This is the test we ran. It opens a page through the proxy, asks a public STUN server for candidates, and prints what WebRTC found:
import { chromium } from 'playwright';
const browser = await chromium.launch({
proxy: { server: 'http://mobile.quanticdata.io:8080',
username: 'USER-country-us-type-mobile-sid-wr01-ttl-30m', password: 'PASS' },
// args: ['--force-webrtc-ip-handling-policy=disable_non_proxied_udp'],
});
const page = await browser.newPage();
await page.goto('https://ipinfo.io/json'); // the IP the page sees
const candidates = await page.evaluate(async () => {
const out = [];
const pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] });
pc.createDataChannel('probe');
pc.onicecandidate = (e) => e.candidate && out.push(e.candidate.candidate);
await pc.setLocalDescription(await pc.createOffer());
await new Promise((r) => setTimeout(r, 6000));
return out; // what WebRTC found
});
A candidate of type srflx ("server reflexive") carries the public IP the STUN server saw. If that IP is not the proxy's, the browser leaks.
What our leak test returned
| Run | IP the page saw | WebRTC candidates | Leak |
|---|---|---|---|
| No proxy | Our line, Italy | mDNS host (.local), srflx with our Italian IP | none to hide |
| Residential Basic, default | A US home IP | mDNS host, srflx with our Italian IP | yes |
| Mobile, default | T-Mobile USA | mDNS host, srflx with our Italian IP | yes |
| Residential Basic, policy set | A US home IP | none | no |
| Mobile, policy set | T-Mobile USA | none | no |
Two things stand out. The local address was already hidden: Chromium replaces it with a random .local name (mDNS), so no 192.168 address appeared. The public address was not: by default, every proxied run still handed the page our Italian IP through the srflx candidate. With the policy set, WebRTC produced no candidate at all, so there was nothing to read.
We repeated it on browserleaks.com/webrtc, a public leak test page, through the mobile line. By default it reported "No Local IP Leak" and "WebRTC IP doesn't match your Remote IP", with our Italian address as the public WebRTC IP. With the policy set, it reported "No Leak" and a dash for both local and public IP.
How to read a WebRTC candidate line
These are the two lines Chromium produced in the default run through the mobile proxy, with our own address masked:
candidate:1921712961 1 udp 2113937151 4410eefb-....local 57548 typ host generation 0 ...
candidate:3454085914 1 udp 1677729535 [our IP, masked] 57548 typ srflx raddr 0.0.0.0 rport 0 generation 0 ...
| Field | In our line | Meaning |
|---|---|---|
| Protocol | udp | WebRTC gathers over UDP, which an HTTP proxy does not carry |
| Priority | 2113937151, 1677729535 | Host candidates rank above server reflexive ones |
| Address | a .local name, then our IP | The local address is hidden behind mDNS; the public one is plain |
| Port | 57548 | The UDP port the browser opened |
| Type | host, srflx | host = this device, srflx = the address the STUN server saw. A third type, relay, comes from a TURN server. |
A leak test page only has to read the address in the srflx line and compare it with the IP of the HTTP request. In our default runs they differed: the page came from the proxy, the srflx address from Italy.
How to disable the WebRTC leak
| Where | Setting | Tested here |
|---|---|---|
| Chromium or Chrome started by a script (Playwright, Puppeteer, Selenium) | Launch argument --force-webrtc-ip-handling-policy=disable_non_proxied_udp | Yes, Chromium 149: no candidate left |
| Chrome and Brave with the QuanticData extension | WebRTC leak protection while a session is live | Covered in our Chrome proxy setup and Brave proxy setup guides |
"Disable non-proxied UDP" lets WebRTC use only paths that go through the proxy, so the STUN request that found our real address is never sent. The QuanticData Chrome extension offers WebRTC leak protection while a session is live. For browser automation, add the launch argument next to the proxy settings in your script; the rest of the proxy options are in our Playwright proxy guide.
A five-step leak check for any setup
- Note your real IP with the proxy off.
- Turn the proxy on and load a page that shows your IP: it should be the proxy's.
- Run a WebRTC leak test (the script above, or a public test page).
- Look at the public IP WebRTC reports. If it is the address from step 1, you leak.
- Set the policy, restart the browser, and run step 3 again until no real IP appears.
Check DNS while you are at it: our DNS leak test through a proxy shows the same before-and-after for name lookups.
Residential or mobile behind a leak-free browser
Once WebRTC is closed, the page sees one consistent address: the proxy's. Residential Basic and Premium give home IPs in the country you pick, Mobile gives carrier IPs such as the T-Mobile exits in our runs. The plans are on our pages for residential proxies and mobile proxies, with a Residential Basic free trial to start.
WebRTC is one leak; the browser's time zone, language and fingerprint are others, covered in browser fingerprinting. For the wider picture of what a site can still learn, see how to hide your IP address.


