Network Information API: Fix Connection Fingerprint Leaks (2026)

12 min read

A profile has a clean canvas and WebGL setup, a residential proxy located in suburban Phoenix, and every identity parameter set deliberately. Then you open the console and read effectiveType: "4g" and rtt: 0.

Zero. Chrome rounds RTT to the nearest 25 ms, so that means the browser measured well under 25 ms. Not what you'd expect from a home line in Phoenix reaching a distant server.

Nothing is broken, exactly. The browser is reporting what it measured, and that measurement includes your own machine's connection to the proxy, not only the proxy's. If you're doing QA, ad verification or geo-specific rendering checks, it's worth knowing what the page can see about your path.

This is the Network Information API, one of those fingerprinting inputs that gets far less attention than canvas or WebGL. And unlike canvas, there's no sensible way to "randomise" it. The numbers have to make physical sense for the network you're on.

What We're Building

By the end of this tutorial, you'll know how to:

  1. Query the Network Information API and understand what each value means
  2. Spot combinations that don't fit a given proxy type
  3. Compare API values with what datacenter, residential and mobile connections typically look like
  4. Test your own profiles for connection mismatches
  5. Decide what to do when a mismatch turns up

You'll need a multi-account browser with at least one configured profile and access to DevTools. Use it on your own sites and test pages.

Prerequisites

  • A multi-account browser (JustBrowser, Multilogin, GoLogin, or similar)
  • At least one proxy configured (any type; we'll see what it reports)
  • Basic familiarity with the DevTools Console
  • 20 minutes
  • Optional: a residential and a datacenter proxy to compare

If you haven't set up proxy routing yet, the ISP proxies setup tutorial covers the basics.

Step 1: Understanding What the API Exposes

Open your profile. Launch DevTools (F12 or right-click, then Inspect). Go to Console and type:

console.log(navigator.connection);

You'll see something like:

NetworkInformation {
  effectiveType: "4g",
  downlink: 10,
  rtt: 50,
  saveData: false,
  onchange: null
}

Four values. Each one matters.

effectiveType is the browser's estimate of connection quality. Values: "slow-2g", "2g", "3g", "4g". It isn't the actual technology (LTE vs fiber vs cable). It's a quality bucket based on observed performance. A fiber line reports "4g". A congested LTE tower might report "3g".

downlink is estimated bandwidth in megabits per second, capped at 10 Mbps in Chromium-based browsers to reduce how precisely it identifies you. A privacy decision that sits oddly beside everything else a browser exposes.

rtt is round-trip time in milliseconds, rounded to the nearest 25ms. This is the value most likely to disagree with a proxy's claimed location. Because of the rounding, you'll only ever see 0, 25, 50, 75 and so on, and the figure covers the whole path from your machine, including the hop to the proxy. Understanding RTT patterns helps with browser fingerprinting protection generally.

saveData says whether data saver mode is on. Mostly relevant to mobile. A desktop profile with saveData: true is unusual.

These values update as conditions change. They come from measurement, not configuration. So a fast path to the proxy produces low numbers, whatever the proxy's IP registration says.

Step 2: Which Combinations Look Inconsistent

A site doesn't have to read these values in isolation. It can set them beside IP metadata and geolocation, and some pairings simply don't occur in the real world.

Datacenter IP with a high RTT. If your machine sits close to the proxy, you'd expect a low reading. A profile reporting rtt: 150 suggests a long or congested path somewhere.

Residential IP with an RTT of 0. A home connection reaching a distant server rarely rounds down to zero. It may mean the traffic isn't travelling the path the IP suggests, or simply that you're testing from next door to the proxy.

Mobile IP with fiber-like numbers. effectiveType: "4g", downlink: 10 and rtt: 0 from a carrier IP looks off. Real mobile connections tend to carry more latency and more variance.

Geographic impossibility. A server in New York can't answer a client in rural Wyoming in a couple of milliseconds. Light travels only so fast. This is also why geolocation and timezone have to line up across the whole profile.

Honestly, this is easy to miss and tedious to chase. The Network Information API is poorly explained outside the spec itself, and the ranges you're "supposed" to see aren't documented anywhere official.

Step 3: Testing Your Current Setup

Check what a profile reports. Run this in Console:

const conn = navigator.connection;
console.table({
  effectiveType: conn.effectiveType,
  downlink: conn.downlink,
  rtt: conn.rtt,
  saveData: conn.saveData
});

There's no published table of "correct" values per proxy type, and we won't invent one. RTT is rounded to 25 ms, downlink is capped at 10 Mbps, and both depend on where you're testing from. What you can do is run the test on two proxies of different types, from the same machine, and compare.

A residential proxy that reads rtt: 0 while a mobile one reads 150 tells you something about the paths. A mobile proxy showing a downlink of 10 with an RTT of 0 is worth a closer look. Neither is proof of anything. Both are cues to look at the proxy itself.

For a second opinion, load BrowserLeaks and scroll to the Network Information section. It lists the same values in a readable form.

Step 4: Native Engine vs Extension-Based Tools

The architecture matters more here than for most fingerprinting inputs.

Extension-based tools typically inject JavaScript that overrides the navigator.connection getters. A script reading the property sees whatever the tool is configured to return. But:

  1. The engine still measures real network timing underneath
  2. A page can time its own fetches and compare them with the reported number
  3. When the two disagree, the mismatch itself is the oddity

So a profile might report rtt: 75 while a page's own timing shows far less. That's an inconsistency you can reproduce in a few lines of your own test page.

A custom Chromium engine with native C++ integration, like JustBrowser, isn't an extension, and it's patched on every upstream Chromium release. We haven't verified what its Network Information values look like on any given proxy, so we won't give you a table. Run the console test above on your own profile and proxy, and treat what you measure as the answer.

A JavaScript-level override is the more fragile approach, whatever tool applies it.

Step 5: Deciding What to Do With a Mismatch

If the numbers disagree with the proxy you chose, there are honest options, and none involve hand-writing numbers into a field.

Change the proxy. If a "residential" proxy measures like a datacenter, the provider may be relaying through cloud infrastructure. A different provider or proxy type can change the measured RTT, and the measured RTT is what the browser reports.

Test from a different place. Since RTT includes your own link to the proxy, running from another machine or network changes the reading. If you're verifying how an ad renders from a given city, pick a proxy whose real network path suits the test.

Pick the right proxy for the job. QA against mobile layouts and tests of how a site treats mobile carriers need a real mobile path. JustBrowser lets you bring your own proxies or buy a proxy plan in the app; proxies aren't included in the subscription.

Accept the limit. Some tests don't need the connection signals to be perfect. Know which ones do before you spend an afternoon on them.

One more reason to avoid fiddling with the numbers: a value you've typed in is a claim about a network you aren't on. The cleaner approach is to let the measurement reflect reality and choose the network to suit the task.

Step 6: The WebRTC Cross-Check

WebRTC also exposes connection information, and it can disagree with what the Network Information API implies.

Run this on a test page:

const pc = new RTCPeerConnection();
pc.createDataChannel('');
pc.createOffer().then(offer => pc.setLocalDescription(offer));
pc.onicecandidate = e => {
  if (e.candidate) console.log(e.candidate.candidate);
};

You'll see candidate strings containing addresses and connection types. If WebRTC protection isn't enabled for the profile, candidates gathered through a STUN server can reveal a real address that doesn't match the proxy. Three things should tell one story:

  1. The proxy IP's expected network characteristics
  2. The Network Information API values
  3. The WebRTC-reported addresses

When they don't, you've found a leak in your own setup, which is precisely the point of testing. Make sure the profile's WebRTC settings match your proxy configuration.

Common Errors and Fixes

Error: effectiveType shows "4g" but the page still behaves differently than expected

Cause: The RTT or downlink doesn't fit the IP's network type and location. A residential-looking IP is measuring like a datacenter, or the reverse.

Fix: Run the same test on a second proxy from the same machine and compare. Swapping the proxy or provider usually changes the measurement more than anything else.

Error: Network Information values change between sessions

Cause: They're measured, not stored. A different proxy session, route or time of day changes the result. Some tools may also apply overrides only per session.

Fix: Don't expect fixed numbers. Re-run the console test at the start of a testing session, and note the proxy it was run through.

Error: Values look right but a consistency test still shows a network inconsistency

Cause: Some test pages measure real request timing as well as reading the reported values. If a JavaScript override says 75 ms and real requests complete much faster, those two disagree.

Fix: An override can't change real network performance. Use a proxy whose actual path matches what you want the profile to represent, or run the tests that don't depend on it.

Error: Mobile proxy shows an impossibly low RTT

Cause: The provider assigns mobile IP ranges but routes the traffic through datacenter infrastructure. The IP is registered to a carrier. The path is not a carrier path.

Fix: It's a provider issue. Try another provider, or treat the proxy as what it really is (a fast datacenter path with a mobile ASN).

Next Steps

The Network Information API is one piece of the connection picture. To check a profile end to end:

  1. Check DNS leaks. DNS queries can expose your real network too
  2. Verify timezone matches. A Tokyo proxy with a US timezone is an obvious mismatch
  3. Test WebRTC. Make sure local address exposure matches the proxy
  4. Run a full fingerprint consistency check across the whole profile

For teams running ad verification across geos, consistent connection values mean the pages you capture are the pages that location would actually see. If you track which proxy setups produce clean test runs, JustAnalytics can help you correlate profile configuration with outcomes.

Canvas, WebGL and audio used to get all the attention. The network layer rarely did. It deserves a console check before you trust a profile for a geo-specific test.

Frequently Asked Questions

What data does the Network Information API expose?

The API exposes effectiveType (4g, 3g, 2g, slow-2g), downlink (estimated bandwidth in Mbps), rtt (round-trip time in milliseconds), and saveData (whether data saver mode is enabled). These values are measured dynamically based on actual network performance, not configured by the user. On a normal browser they reflect the real connection. Routed through a fast datacenter proxy, they can look odd next to a location that claims to be a home connection.

Why does the Network Information API matter when you use a proxy?

Sites can compare the API values with what they know about your IP. A home connection with 4g effectiveType and a 50 ms RTT is ordinary. An RTT of 0 next to a mobile-carrier IP is unusual. Mismatches like that are worth finding in your own test profiles, because they can skew QA and ad-verification results.

How do multi-account browsers handle the Network Information API?

A JavaScript override of navigator.connection changes what a script reads but not how long requests actually take, so the two can disagree. JustBrowser is built on a custom Chromium engine with native C++ integration rather than an extension, but we haven't verified its Network Information output for any given proxy. Check any tool yourself with the console test in this post.

Can I test what my profile reports for the Network Information API?

Yes. Open DevTools, go to Console, and run: navigator.connection.effectiveType, navigator.connection.downlink, navigator.connection.rtt. Compare the numbers with what your proxy's location and type would plausibly produce. BrowserLeaks also lists these values.


Try JustBrowser

A multi-account browser for teams, built on a custom Chromium engine with native C++ integration, not an extension. Each profile is its own browser, with its own cookies, storage and proxy, and there are 40+ identity parameters. REST API and CDP 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 Multilogin / GoLogin / AdsPower

Tags
  • network-information-api
  • browser-fingerprinting
  • proxy-detection
  • connection-type
  • multi-account-browser
  • buildinpublic
  • saasstudio
  • aiworkforce
  • buildwithclaude

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, and Google Ads and Microsoft Advertising to measure our ads and show them to people who have visited us. They set cookies in your browser and run 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, and Google Ads and Microsoft Advertising measure our ads and show them to people who have visited us. They set the cookies _ga, _ga_TVZHQ99TZW, _gcl_au, _uetsid and _uetvid, and, after a click on one of our ads, _gcl_aw or _uetmsclkid. They are now onoff in this browser. If your browser sends a Global Privacy Control or Do Not Track signal, they stay off. Cookie Policy