Knowing how to test a proxy before it touches production is the cheapest insurance you will ever buy. Providers mislabel pools all the time — datacenter IPs sold as residential, dead nodes hiding behind a healthy gateway, sticky sessions that quietly rotate on the third request — and every one of those defects surfaces later as broken jobs, mystery blocks and burned accounts. A fifteen-minute test protocol catches almost all of it up front.
This guide walks through the five checks that matter: identity (does the exit IP really belong to a consumer ISP?), protocol behavior (do SOCKS5 and HTTP(S) both work as advertised?), DNS handling (is resolution happening remotely, or leaking your server’s location?), speed (latency and throughput through the tunnel), and sticky-session stability (does the same session ID hold the same IP over time?). Each check comes with a concrete command or tool you can run today, and together they take about fifteen minutes per pool — less time than one debugging session after a bad pool reaches production.
What a proxy test needs to prove
- Identity and ASN: the exit IP should belong to a consumer or residential ISP ASN, not a hosting range. “Datacenter sold as residential” is the most common proxy fraud, and an ASN lookup exposes it in seconds.
- Protocol behavior: SOCKS5 and HTTP CONNECT should both work if advertised, return sane error codes under load, and handle long-lived connections without dropping, because connection churn at scale surfaces as latency spikes and failed jobs.
- DNS and geo integrity: the resolver used for domain lookups must sit in the same country as the exit IP; local resolution leaks your server’s location and poisons geo-dependent content.
- Performance and stability: latency, throughput and — critically — whether sticky sessions actually stick over minutes and hours, because sessions that wander break logins and carts — the most expensive failure a pool can have, since it corrupts stateful workflows rather than single requests.
How to test a proxy: the five checks
- ASN lookup. Echo the exit IP with
curl -x socks5h://user:pass@gateway:port https://api.ipify.org, then paste the result into an ipinfo.io or bgpview lookup. Expect a consumer ISP ASN (Comcast, Deutsche Telekom, NTT…), not AWS, OVH or Hetzner. - Protocol test. Run the same request through both endpoint types —
curl -x http://user:pass@gateway:port https://httpbin.org/getandcurl -x socks5h://user:pass@gateway:port https://httpbin.org/get— and verify both return 200 with the same exit IP. Note thatsocks5hresolves DNS remotely while plainsocks5resolves locally — that one letter is the difference between geo-consistent and geo-leaking requests. - DNS-leak test. Open dnsleaktest.com or ipleak.net through the tunnel and confirm every resolver shown sits in the exit country. A resolver in your server’s region means DNS is leaking — the classic bug behind “wrong localized content.”
- Speed test. Measure both latency and throughput, e.g.
curl -x socks5h://user:pass@gateway:port -o /dev/null -s -w '%{time_connect} %{speed_download}\n' https://speed.cloudflare.com/__down?bytes=10000000. Repeat five times and drop the outliers before judging the node — single-sample speed numbers on residential hops are mostly noise. - Sticky-session stability. Hit the session endpoint five times over ten minutes with the same session ID (provider-specific username suffix or header) and confirm the exit IP never changes. Two different IPs from “one session” means the stickiness is fake.
- Score and log everything. Record pass/fail per check per node, with the date and pool version noted. Anything that fails a single check goes back to the provider before you write a line of production code.
Comparison
Each check exists because it catches a specific failure mode:
| Test | How to run it | What it catches |
|---|---|---|
| ASN/identity lookup | ipinfo.io or bgpview on the echoed IP | Datacenter IPs sold as residential; abuse-recycled ranges |
| Protocol test | curl through http:// and socks5h:// | Broken SOCKS5, silent protocol downgrade |
| DNS-leak test | dnsleaktest.com through the tunnel | Local DNS resolution leaking the server’s geo |
| Speed test | curl -w timing through the tunnel | Oversold nodes, congested routes, unstable latency |
| Sticky stability | Same session ID, 5 requests over 10 minutes | Fake stickiness that breaks login and cart flows |
How to test a proxy before you pay for it
- Start with a trial or the smallest paid plan. Never bulk-buy an untested pool — reputable providers expect this.
- Sample broadly: test 10–20 nodes across your target geographies, not a single lucky endpoint — pools are not homogeneous, and one good node proves nothing about the rest.
- Test the exact protocol your application uses. If production speaks SOCKS5h, test SOCKS5h; HTTP results do not transfer.
- Verify geo-targeting claims: request city X and confirm the echoed IP actually sits in city X, at ASN level.
- Add concurrent load: run five parallel sessions for a minute and watch failure rate and latency drift.
- Record a baseline and a re-test schedule so degradation over weeks becomes measurable instead of anecdotal.
Common mistakes when testing proxies
- Testing only from the provider dashboard: dashboards display the healthiest nodes, not necessarily the ones your requests will get; always test through the exact endpoint and credentials production will use.
- Treating one good node as proof: a single passing test hides pool-wide variance; sample the distribution.
- Testing HTTP while production uses SOCKS5 (or the reverse): protocol results do not generalize.
- Skipping sticky verification: teams discover fake stickiness only after login states start dropping mid-run.
FAQ
How can I test a proxy before paying?
Use a free trial, the smallest paid plan, or a provider with a refund policy, then run the five checks above on a representative sample. Any provider that refuses trial access on residential pools is telling you something about the pool.
What is a good failure rate for a proxy pool?
For residential traffic, aim for under 1–2 percent failed requests after retries; sticky sessions should hold at essentially zero failures. If a pool needs more than one retry to land most requests, treat it as degraded regardless of what the dashboard claims. Track the number per pool and per geo, not just globally — localized degradation is invisible in an aggregate.
Why does speed vary so much between exit IPs?
Each exit sits behind a different consumer last mile — different ISPs, different congestion, different distances to your target. Expect two- to five-fold throughput variance across a healthy residential pool and design timeouts for the slow tail, not the average. This is also why speed results from one node tell you nothing about the pool — sample the distribution.
How often should I re-test my proxies?
Weekly for business-critical jobs, always before large scheduled runs, and immediately after any provider-side change. Automate the five checks as a script so re-testing costs nothing and produces comparable numbers over time, and tie the schedule to a recurring calendar event so it survives team turnover.
Testing turns proxy buying from faith into engineering: five checks, fifteen minutes, and a written baseline per pool that anyone on the team can re-run. For the low-level networking details, our cURL SOCKS5 guide covers socks5h versus socks5 and forcing remote DNS, and datacenter vs residential explains why the ASN check matters so much. When you are ready, FTProxy residential proxies come with the trial access you need to run every check above before you commit.