How to Verify a Residential Proxy Pool Before You Buy (With Real Numbers)

Zhu Lan — Fri, 06 Nov 2026 00:31:29 +0000

Every proxy provider claims "millions of IPs in 190+ countries". Almost none of those numbers mean what you think they mean. Here's how to measure what you're actually paying for — with a method you can run against any provider, including the one you currently use.

Why the advertised numbers are misleading

When a provider says "80M residential IPs", that's typically the size of a historical database — IPs that have been in the pool at some point, not IPs that are alive right now. The real questions for your scraper are:

How many IPs are online right now in the country you target?
What's the success rate on your actual target sites?
Does the provider even know their own numbers?

Method 1: Country-level pool depth

Pick your target country and request a rotating IP in that country 20–50 times in a row. Then check how many unique IPs you got back.

import requests

UNIQ = set()
for i in range(50):
    r = requests.get(
        "https://api.ipify.org",
        proxies={"http": "http://user-pass-country-us:pass@gw.provider.com:8000"},
        timeout=15,
    )
    UNIQ.add(r.text)
print(f"unique IPs: {len(UNIQ)}/50")

If 50 requests return 12 unique IPs, your "US pool" is effectively 12 IPs for your session pattern — regardless of what the landing page says.

A transparent provider publishes these numbers themselves. IPLight, for example, shows live per-country pool counts measured from their actual pool (215k+ online IPs across 170+ countries at the time of writing) — the US page says exactly how many US IPs are online, not "5M+".

Method 2: Success rate on YOUR target

Benchmarks on "Amazon / Google / etc." are nice, but your workload is what matters. Run 100 requests against your real target with a small concurrency:

import concurrent.futures, requests

TARGET = "https://your-target-site.com/page"
PROXY = {"http": "http://user:pass@gw.provider.com:8000"}
ok = 0

def hit(_):
    try:
        r = requests.get(TARGET, proxies=PROXY, timeout=20)
        return 200 <= r.status_code < 300 and "expected-anchor" in r.text
    except Exception:
        return False

with concurrent.futures.ThreadPoolExecutor(10) as ex:
    ok = sum(ex.map(hit, range(100)))
print(f"success: {ok}%")

Key detail: check the content, not just the status code. A 200 with a Cloudflare challenge page is a failure.

Method 3: Rotation quality

Repeat Method 1 with sleep(60) between requests. If the same IP comes back after an hour, the provider's "rotating" pool is recycling aggressively — fine for low-stakes scraping, dangerous for account-bound work.

What the numbers should look like

For a healthy residential provider, on a moderately protected target:

Metric	Acceptable	Concerning
Unique IPs in 50 requests	> 45	< 30
Content-verified success rate	> 90%	< 70%
Same IP returning after 1h	never	often

The uncomfortable takeaway

Most providers won't publish live pool counts because the real numbers are smaller than the marketing numbers. That's exactly why you should measure before committing — and prefer vendors who publish their own measurements, because a provider that's honest about pool size is usually honest about the other things that matter (IP sourcing, logging, session behavior).

Run the three methods above against your current provider this week. If the numbers embarrass either of you, you just saved yourself the next billing cycle.

Disclosure: I work with IPLight, whose transparency practices inspired the checklist — but the measurement methods above are provider-agnostic and you should run them yourself.