To test if a proxy is working, you need to answer more than "does it connect?". A useful test checks five things: the proxy accepts your credentials, traffic exits from a different IP, that IP is in the right country, it's fast enough, and it behaves correctly on the site you actually care about. This guide walks through each step with curl and Python, from a ten-second sanity check to a proper success-rate measurement.
Step 1: The One-Line curl Test
curl -x http://USERNAME:[email protected]:8080 https://api.ipify.orgIf this prints an IP address that isn't yours, the proxy is up and your credentials are accepted. Compare it with the IP you get without the proxy, or open our what is my IP tool in your normal browser.
If it fails, add -v to see why. A 407 means the credentials or plan are the problem; work through our 407 checklist. A 402 means the plan is out of bandwidth. "Failed to connect" means the host or port is wrong or something on your network blocks outbound traffic.
Step 2: Check the Exit IP's Country and Network
An IP alone doesn't tell you where the target thinks you are. Use a geolocation endpoint that returns country and network details:
curl -x http://USERNAME-country-gb:[email protected]:8080 https://ipinfo.io/jsonCheck the country field matches the country option you set, and look at the org field, which shows the network (ASN) the IP belongs to. For residential and mobile proxies, it should name a consumer ISP or mobile carrier. For datacenter proxies, a hosting company is expected. Geolocation databases disagree at the city level, so treat city results from any single lookup as approximate.
Step 3: Measure Latency
curl can break down where the time goes:
curl -x http://USERNAME:[email protected]:8080 -o /dev/null -s \
-w "proxy connect: %{time_connect}s\ntunnel+tls: %{time_appconnect}s\nfirst byte: %{time_starttransfer}s\ntotal: %{time_total}s\n" \
https://www.example.comtime_connect is the TCP connection to the gateway. time_appconnect includes the CONNECT tunnel and TLS handshake through the proxy to the site. time_starttransfer is when the first byte arrived. One measurement is noise; run it 10 to 20 times and look at the median and the slowest results. Residential and mobile IPs are real consumer connections, so expect more variation than datacenter IPs. Picking an exit country close to the target server usually helps.
Step 4: Test Rotation vs Sticky Sessions
With no session option, the gateway gives you a new IP per request. With a session option, the same session ID keeps the same IP until its time runs out. Test both, because using the wrong one is a common source of bugs. This Python script does it:
import time, uuid, statistics, requests
USER, PASS = "USERNAME", "PASSWORD"
GATEWAY = "global.nodeproxies.xyz:8080"
def check(username, n=5):
proxy = f"http://{username}:{PASS}@{GATEWAY}"
ips, times = [], []
for _ in range(n):
start = time.perf_counter()
r = requests.get("https://api.ipify.org", proxies={"http": proxy, "https": proxy}, timeout=20)
times.append(time.perf_counter() - start)
ips.append(r.text.strip())
print(username)
print(" unique IPs:", len(set(ips)), "of", n)
print(" median latency: %.2fs" % statistics.median(times))
check(USER) # rotating: expect several unique IPs
check(f"{USER}-session-{uuid.uuid4().hex[:8]}-time-10") # sticky: expect 1 unique IPRotating should show several unique IPs (occasionally a repeat is normal in a large pool). Sticky should show exactly one. If sticky keeps changing, make sure the session ID stays identical across requests and isn't regenerated each time. Our rotating vs sticky guide explains when to use each.
Step 5: Test on Your Real Target
A proxy that works on api.ipify.org can still fail on the site you care about, because IP-check services don't block anyone. The test that matters is a small batch against your actual target:
import collections, requests
proxy = "http://USERNAME-country-us:[email protected]:8080"
proxies = {"http": proxy, "https": proxy}
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36"}
codes = collections.Counter()
for url in ["https://example.com/page-1", "https://example.com/page-2"] * 25:
try:
r = requests.get(url, proxies=proxies, headers=headers, timeout=30)
codes[r.status_code] += 1
except requests.RequestException as e:
codes[type(e).__name__] += 1
print(codes) # e.g. Counter({200: 48, 403: 2})Use real URLs you're allowed to fetch, keep the request rate modest, and also check the page content: some sites return 200 with a block or CAPTCHA page. If you see mostly 403 or 429, the proxy is working but the target is pushing back. That's a scraping-behavior or proxy-type issue, covered in how to avoid getting blocked.
A Quick Checklist
- Connects and returns a different IP: credentials and plan are fine.
- Country and org match what you asked for: targeting works.
- Median latency is acceptable over 10 or more requests: the route is usable.
- Rotating gives new IPs and sticky holds one IP: the session setup is right.
- Success rate on the real target is acceptable: the proxy type fits the job.
Testing NodeProxies
You don't need a big plan to run these tests. Plans start at 100 MB and the minimum deposit is $3, with no subscription, so you can compare residential and datacenter on your own target before committing to volume. The dashboard's proxy generator builds the usernames for each test, and pricing lists the per-GB rates.
FAQ
How do I know if my proxy is actually being used?
Fetch an IP-check endpoint through the proxy and compare the result with your real IP. If they match, your traffic isn't going through the proxy.
What is a good proxy latency?
It depends on the proxy type and distance to the target. Datacenter IPs are usually fastest; residential and mobile vary more. Judge by the median over many requests on your real target, not a single ping.
Why does my proxy work on IP checkers but not on my target site?
IP checkers don't block traffic. Your target may be rate limiting, blocking the IP type, or flagging your headers. Test with realistic headers and slower request rates, or try residential IPs.
How can I check a proxy's location?
Request a geolocation endpoint such as ipinfo.io/json through the proxy and read the country field. City-level results vary between databases, so treat them as approximate.
