Proxy Speed and Quality: What to Measure and What Is Good

The "Good" column is the top band each benchmark's figures support; the bands between them are rules of thumb for a buyer's test.

Three public sources back the bands above. Read their figures as ranges across providers, not as a score for any one network.

Three lessons for your own test follow from them:

• Simple endpoints flatter everyone. Almost every provider scores 99% or more on a CDN or IP-check URL; the gap opens on real targets, so always test your own.
• One run is not enough. On Amazon, the same provider's success swung from about 28% to 83% between runs, so test at two or more times of day and on more than one day.
• Sticky sessions vary most. Stability spread from 47.3% to 87.2%, more than any other figure, so test sessions if your work needs a fixed IP.

ProxyField's own figures, all according to our service data: a 99.6% success rate, an average response of about 400 ms, under 1 s typical response for residential and under 1.5 s for mobile. These are our figures, not benchmark results, so measure on your own targets as below.

Speed is several measurements, and providers do not always mean the same one.

For scraping and monitoring, response time and success rate matter most: most pages are small, so you wait on round trips, not on bandwidth. A fast proxy that gets blocked is slower in practice than a slower one that succeeds, because every failure costs a retry.

There is no single number, because each proxy type adds a different detour. As a rule of thumb, from how each type routes traffic:

ProxyField's own figures, according to our service data: an average response of about 400 ms, under 1 s typical response for residential and under 1.5 s typical response for mobile. If your residential requests regularly take several seconds, look at what sits around the proxy first: the distance to the target, a browser loading whole pages, or slow connection setup in your client. Fixes for that are in why your proxies are slow.

Yes. A US website answers a US exit faster than a German one, because the last leg is shorter, so performance differs between the US, Europe and Asia mostly by distance to the target. Pick the exit country by what the website should see: for local prices, results or ads, you need the local view whatever it costs in milliseconds; for data that is the same everywhere, choose an exit near the website's servers. ProxyField has 412M+ residential IPs in 195+ countries, with targeting by country, region (state) and city: see proxy location targeting.

A proxy rarely lowers your ping in a game or app: it adds a hop. It helps only when your provider's own route to the server is poor and the proxy's route is better, which is uncommon.

Success rate is the share of requests that return the content you asked for, not just a 200 OK. A block page, a CAPTCHA challenge or an empty shell served with status 200 is a failure.

• It depends on the target. The same pool can succeed on almost every request to a public catalog and far fewer on a heavily protected site. Compare providers on the same target, at the same time.
• Ask whether it is measured before or after retries. A rate after 3 retries looks better and costs 3 times the traffic on failures.
• Uptime is a different number. Uptime says whether the gateway answered at all; success rate says whether the website gave you the page. A gateway can be up while a target blocks most of its IPs, so for scraping, success rate on your target is the number to watch.
• Separate your errors from the proxy's. 407 is a proxy login problem, 403 and 429 usually come from the website, and timeouts can be either. The proxy errors guide lists them.

ProxyField runs at a 99.6% success rate, according to our service data. On your own target, measure it as below.

Pool quality shows in honest numbers and in what you can check yourself. Signs to check in any provider:

• City targeting that does not match. Request a city and check where the exit IP is; IP location databases disagree near borders and on mobile networks, so check a sample, not one IP.
• Speed or uptime promises with no method. A figure without the target, the period and how failures were counted tells you little; "100% uptime" is a promise no network keeps.
• No small purchase to test with. You should be able to test on your own targets before a large order.

At ProxyField, the pool is clean for Google, checked and segmented. How to check a provider's policies before paying is covered in the Trust Center.

The test that predicts your results is your own target, your own request pattern and enough requests to count.

1. Pick 1 or 2 real targets and 50-100 real URLs on each.
2. Send 200-500 requests through the proxy, with the headers and concurrency you will use in production, spread over several hours: first with no retries, then with your usual retries.
3. Count a success only when the response contains the content you expect (a product title, a price), not just status 200.
4. Record response times and look at the median and the slowest 5%, not only the average.
5. Repeat per country you need, at another time of day and on another day: one run can swing far on a protected target.
6. Test sessions with the session test below: 8 sticky sessions of 30 minutes, one IP check every 30 seconds, and the share of sessions that kept one IP.
7. Work out the cost per 1,000 successful pages: price per GB × GB used ÷ successful pages × 1,000. At 100 KB per page (an example size), 1,000 pages are about 0.1 GB: about $0.30 at ProxyField's $2.95/GB and $0.20 at $1.95/GB, plus the traffic of failed attempts.

A small tester in Python does steps 2-4:

import statistics, time
from concurrent.futures import ThreadPoolExecutor
import requests

PROXY = "http://<login>-country-us-city-new_york:<password>@gate.proxyfield.io:7000"
URLS = [line.strip() for line in open("urls.txt") if line.strip()]
MARKER = "Add to cart"  # text that only a real page contains

def fetch(url):
    start = time.perf_counter()
    try:
        r = requests.get(url, proxies={"http": PROXY, "https": PROXY}, timeout=30,
                         headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"})
        ok = r.status_code == 200 and MARKER in r.text
        return ok, time.perf_counter() - start, r.status_code
    except requests.RequestException:
        return False, time.perf_counter() - start, None

with ThreadPoolExecutor(max_workers=10) as pool:
    results = list(pool.map(fetch, URLS))

def percentile(xs, q):  # nearest rank on a sorted list
    return xs[max(0, min(len(xs) - 1, round(q * (len(xs) - 1))))]

times = sorted(t for ok, t, _ in results if ok)
print(f"success: {sum(ok for ok, _, _ in results)}/{len(results)}")
if times:
    print(f"median: {statistics.median(times):.2f} s, p90: {percentile(times, 0.90):.2f} s, p95: {percentile(times, 0.95):.2f} s")
print("status codes:", {code: sum(1 for _, _, c in results if c == code) for _, _, code in results})

The username in the code, <login>-country-us-city-new_york, is an example: an exit in New York City, United States. The syntax for region (state) and sticky sessions is -region-<region>, -session-<id> and -ttl-<seconds> (30 to 129,600 seconds, 20 minutes by default) after the location, as in <login>-country-us-region-new_york-city-new_york-session-he9f2qga-ttl-600, and countries outside the US take their two-letter code in lowercase, as in -country-de. For a quick check of a proxy list without code, the proxy checker tests up to 100 proxies at once.

Test that sticky sessions hold their IP

This test opens 8 sticky sessions of 30 minutes each and asks every session for its exit IP every 30 seconds, as the October 2026 benchmark did, so no session is idle for long and your stability score compares with the published 47.3–87.2%:

import time
import requests

LOGIN, PASSWORD = "<login>", "<password>"
SESSIONS, TTL, EVERY = 8, 1800, 30  # 8 sessions, ttl 1,800 s (30 min), one check per session every 30 s

def exit_ip(session):
    user = f"{LOGIN}-country-us-session-test{session}-ttl-{TTL}"
    proxy = f"http://{user}:{PASSWORD}@gate.proxyfield.io:7000"
    try:
        return requests.get("https://api.ipify.org", proxies={"http": proxy, "https": proxy}, timeout=10).text.strip()
    except requests.RequestException:
        return None

seen = {s: [] for s in range(SESSIONS)}
for _ in range(TTL // EVERY):
    for s in seen:
        seen[s].append(exit_ip(s))
    time.sleep(EVERY)

stable = 0
for s, ips in seen.items():
    got = [ip for ip in ips if ip]
    changes = sum(1 for a, b in zip(got, got[1:]) if a != b)
    stable += changes == 0 and len(got) >= 0.9 * len(ips)
    print(f"session {s}: {len(got)}/{len(ips)} answered, {len(set(got))} IPs, {changes} changes")
print(f"stability: {100 * stable / SESSIONS:.0f}% of sessions kept one IP")

What to expect from ProxyField:

• One IP per session for the whole ttl. A sticky IP is held while its exit node is up. Session times run from 30 to 129,600 seconds (36 h); a session set without ttl lasts 20 minutes.
• An idle IP is replaced after 120 s. To see it, stop one session for 150 seconds and check again: it returns a new IP. Keep-alive traffic every 30 to 60 seconds avoids it.
• A dropped node can change the IP. On a connection error the gateway retries once with a new session, so the IP may change; an established connection that breaks is not restored, and your client reconnects. Count these changes separately from the ones you caused.

A session counts as stable when it kept one IP and answered at least 90% of the checks. 80% or more stable sessions is a good result against the public benchmark; for a single provider you can hold it to a stricter pass, 8 of 8. Changes that come with failed requests point to dropped nodes, and changes without failures point to a session or ttl typo in the username.

The Easy Trial is sized for exactly this: 1 GB for $2.95 (mobile $3.45) covers about 10,000 HTML pages at 100 KB each (an example size), with no minimum purchase and no subscription. You get the same pool and the same quality at 1 GB as at 1 TB: there is no separate trial pool.

Open https://api.ipify.org (or any "what is my IP" page) through the tool, then compare the IP with your own: if they match, the proxy is not in use. Through a rotating ProxyField gateway, 2 calls a few seconds apart should return different IPs, and a sticky session should return the same one. Setup steps for each tool are in how to set up a proxy.

Raw speed matters when the job is many small requests against a tolerant site, such as monitoring your own pages or checking API endpoints; datacenter proxies suit that, and ProxyField's rotating datacenter traffic costs from $0.29/GB down to $0.22/GB. When the target defends itself, success rate beats speed, and residential IPs win: a request that succeeds in 1 second is faster than 3 that fail in 200 ms each. Which type fits which job is in residential vs datacenter proxies.