Before you add a proxy to any application, confirm it actually works. A proxy can accept the TCP connection and still fail to route traffic, return your real IP, or time out on HTTPS. This guide shows you exactly how to test a proxy in every environment you will encounter — browser, command line, Python, and online proxy checker tools — so you know what is happening at each layer before writing a single line of application code.

A proxy has several independent failure modes. Each one produces a different symptom:

| What Can Fail | Symptom | Test That Catches It |

|---|---|---|

| TCP connection to proxy | Connection refused or timeout | curl --proxy with a fast timeout |

| Proxy authentication | 407 Proxy Authentication Required | curl -x user:pass@host:port |

| HTTP routing (port 80) | Real IP shown, or ERR_TUNNEL_CONNECTION_FAILED | Check exit IP on httpbin.org/ip |

| HTTPS tunneling (CONNECT) | Real IP shown for HTTPS requests only | Check exit IP via an HTTPS URL |

| DNS leaking through proxy | Proxy IP shown but DNS resolves locally | DNS leak test at dnsleaktest.com |

"The proxy is working" means all five pass. Many tutorials only check the exit IP on HTTP — which passes even when HTTPS tunneling is broken. Run every test in this guide for a complete proxy check.

The quickest manual test proxy method is configuring a browser to use the proxy and then visiting an IP-reveal site.

curl is the fastest way to check proxy connectivity from the command line. It is available on Windows (via curl.exe bundled since Windows 10), Mac, and Linux.

The Python requests library is the most precise way to test proxy behavior programmatically.

```python

import requests

def test_proxy(proxy_url: str, timeout: int = 10) -> dict:

"""

Returns a result dict with status, exit_ip, and latency.

proxy_url format: "http://host:port" or "http://user:pass@host:port"

"""

proxies = {"http": proxy_url, "https": proxy_url}

try:

resp = requests.get(

"https://httpbin.org/ip",

proxies=proxies,

timeout=timeout,

)

resp.raise_for_status()

return {

"proxy": proxy_url,

"status": "ok",

"exit_ip": resp.json().get("origin"),

"latency_ms": int(resp.elapsed.total_seconds() * 1000),

"http_code": resp.status_code,

}

except requests.exceptions.ProxyError as exc:

return {"proxy": proxy_url, "status": "proxy_error", "error": str(exc)}

except requests.exceptions.ConnectTimeout:

return {"proxy": proxy_url, "status": "timeout"}

except requests.exceptions.RequestException as exc:

return {"proxy": proxy_url, "status": "failed", "error": str(exc)}

result = test_proxy("http://your-proxy.sparkproxy.com:10000")

print(result)

{"proxy": "http://...", "status": "ok", "exit_ip": "1.2.3.4", "latency_ms": 312, "http_code": 200}

```

Test multiple proxies in parallel:

```python

from concurrent.futures import ThreadPoolExecutor

PROXIES = [

"http://your-proxy-1.sparkproxy.com:10000",

"http://your-proxy-2.sparkproxy.com:10001",

"http://your-proxy-3.sparkproxy.com:10002",

]

with ThreadPoolExecutor(max_workers=10) as executor:

results = list(executor.map(test_proxy, PROXIES))

for r in results:

status = r["status"]

ip = r.get("exit_ip", "N/A")

ms = r.get("latency_ms", "N/A")

print(f"[{status:12}] {r['proxy']} → {ip} ({ms} ms)")

```

A critical step that most check proxy guides omit: verify that HTTPS traffic — not just HTTP — routes through the proxy. Many proxy configurations work for HTTP but silently fall back to your real IP for HTTPS.

```python

import requests

def test_proxy_full(proxy_url: str, timeout: int = 10) -> dict:

proxies = {"http": proxy_url, "https": proxy_url}

results = {}

HTTP test

try:

r = requests.get("http://httpbin.org/ip", proxies=proxies, timeout=timeout)

results["http_ip"] = r.json().get("origin")

except Exception as exc:

results["http_ip"] = f"FAILED: {exc}"

HTTPS test

try:

r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=timeout)

results["https_ip"] = r.json().get("origin")

except Exception as exc:

results["https_ip"] = f"FAILED: {exc}"

Consistency check

results["consistent"] = results["http_ip"] == results["https_ip"]

results["proxy"] = proxy_url

return results

r = test_proxy_full("http://your-proxy.sparkproxy.com:10000")

print(r)

{"http_ip": "1.2.3.4", "https_ip": "1.2.3.4", "consistent": True, ...}

```

If consistent is False — HTTP and HTTPS return different IPs — the proxy routes HTTP traffic but not HTTPS. The fix is on the proxy server side (CONNECT tunneling must be enabled).

Proxy latency is the time from sending the request to receiving the first byte of response through the proxy. It includes TCP connect time, proxy processing time, and target server response time.

```python

import time

import requests

def measure_proxy_latency(

proxy_url: str,

test_url: str = "https://httpbin.org/ip",

runs: int = 5,

) -> dict:

proxies = {"http": proxy_url, "https": proxy_url}

latencies = []

for _ in range(runs):

try:

resp = requests.get(test_url, proxies=proxies, timeout=15)

latencies.append(resp.elapsed.total_seconds() * 1000)

except requests.exceptions.RequestException:

latencies.append(None)

valid = [l for l in latencies if l is not None]

if not valid:

return {"proxy": proxy_url, "status": "all_failed"}

return {

"proxy": proxy_url,

"runs": runs,

"success": len(valid),

"avg_ms": round(sum(valid) / len(valid)),

"min_ms": round(min(valid)),

"max_ms": round(max(valid)),

"failed": runs - len(valid),

}

result = measure_proxy_latency("http://your-proxy.sparkproxy.com:10000")

print(result)

{"proxy": "...", "runs": 5, "success": 5, "avg_ms": 287, "min_ms": 241, "max_ms": 334, "failed": 0}

```

Latency benchmarks for datacenter proxies:

| Latency | Assessment |

|---|---|

| < 100 ms | Excellent — same-region proxy |

| 100–300 ms | Good — cross-region, still fast |

| 300–600 ms | Acceptable — inter-continental routing |

| > 600 ms | Slow — consider a closer proxy node |

proxy speed and latency

Online proxy checker tools test a proxy from their own servers, which means they test the proxy's reachability from a remote location rather than from your machine. Use them to confirm the proxy is publicly accessible, not just accessible from your local network.

| Tool | What It Tests | Best For |

|---|---|---|

| https://httpbin.org/ip | Exit IP (visited through the proxy via curl/Python) | Scripted testing |

| https://ipv4.icanhazip.com | Exit IP (plain text response) | Minimal response parsing |

| https://www.whatismyipaddress.com | Exit IP + geolocation + ISP | Manual browser testing |

| https://dnsleaktest.com | DNS leak — are DNS queries bypassing the proxy? | DNS leak verification |

| https://browserleaks.com/ip | Exit IP + WebRTC leak + timezone | Browser privacy testing |

Note on third-party proxy checker websites: Tools that ask you to enter a proxy host and port and test it remotely (rather than from your machine) measure reachability from their servers. This is useful for confirming the proxy is publicly online but does not tell you whether it works from your specific server or cloud instance. Always run a local test (curl or Python) in addition to an online tool.

If your proxy uses username and password authentication rather than IP whitelisting, test authentication separately from connectivity.

```python

import requests

def test_proxy_auth(host: str, port: int, username: str, password: str) -> dict:

proxy_url = f"http://{username}:{password}@{host}:{port}"

proxies = {"http": proxy_url, "https": proxy_url}

try:

resp = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)

if resp.status_code == 407:

return {"status": "auth_failed", "detail": "407 Proxy Authentication Required"}

resp.raise_for_status()

return {

"status": "ok",

"exit_ip": resp.json().get("origin"),

"http_code": resp.status_code,

}

except requests.exceptions.ProxyError as exc:

ProxyError wraps 407 in some urllib3 versions

return {"status": "auth_failed", "error": str(exc)}

except requests.exceptions.RequestException as exc:

return {"status": "connection_failed", "error": str(exc)}

result = test_proxy_auth(

host="your-proxy.sparkproxy.com",

port=10000,

username="YOUR_USERNAME",

password="YOUR_PASSWORD",

)

print(result)

```

proxy authentication

Common authentication failure causes:

| Symptom | Most Likely Cause |

|---|---|

| 407 Proxy Authentication Required | Wrong username or password |

| Connection refused | Correct credentials, but machine IP is not whitelisted (if IP auth required) |

| 403 Forbidden | Account suspended or quota exceeded |

| Auth succeeds, but wrong exit IP | Credentials belong to a different sub-account or pool |

For production use, run an automated health check before each scraping job and periodically during long runs. This script tests HTTP, HTTPS, latency, and authentication in one pass:

```python

import requests

import concurrent.futures

import json

from datetime import datetime, timezone

def full_proxy_check(proxy_url: str, timeout: int = 10) -> dict:

"""

Comprehensive single-proxy health check.

Tests HTTP exit IP, HTTPS exit IP, latency, and consistency.

"""

proxies = {"http": proxy_url, "https": proxy_url}

result = {

"proxy": proxy_url,

"timestamp": datetime.now(timezone.utc).isoformat(),

"http_ip": None,

"https_ip": None,

"latency_ms": None,

"consistent": False,

"status": "failed",

}

HTTP test

try:

r = requests.get("http://httpbin.org/ip", proxies=proxies, timeout=timeout)

result["http_ip"] = r.json().get("origin")

except Exception:

result["error"] = "http_failed"

return result

HTTPS test

try:

r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=timeout)

result["https_ip"] = r.json().get("origin")

result["latency_ms"] = int(r.elapsed.total_seconds() * 1000)

except Exception:

result["error"] = "https_failed"

return result

result["consistent"] = result["http_ip"] == result["https_ip"]

result["status"] = "ok" if result["consistent"] else "inconsistent"

return result

def check_all(proxy_list: list[str], workers: int = 20) -> list[dict]:

with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:

results = list(executor.map(full_proxy_check, proxy_list))

ok = [r for r in results if r["status"] == "ok"]

failed = [r for r in results if r["status"] != "ok"]

print(f"Healthy: {len(ok)}/{len(proxy_list)}")

if failed:

print(f"Failed ({len(failed)}):")

for r in failed:

print(f" {r['proxy']} → {r.get('error', r['status'])}")

return ok # Return only healthy proxies for use in your application

PROXIES = [

"http://your-proxy-1.sparkproxy.com:10000",

"http://your-proxy-2.sparkproxy.com:10001",

"http://your-proxy-3.sparkproxy.com:10002",

]

healthy = check_all(PROXIES)

print(json.dumps(healthy, indent=2))

```

| Error / Symptom | Cause | Fix |

|---|---|---|

| Exit IP matches your real IP (HTTP) | Proxy not accepting traffic on that port | Confirm port number in SparkProxy dashboard; try alternate port |

| Exit IP matches your real IP (HTTPS only) | Proxy doesn't support HTTP CONNECT | Contact provider; switch to a proxy with CONNECT support |

| 407 Proxy Authentication Required | Wrong credentials or IP not whitelisted | Check username/password; add your IP to whitelist |

| Connection refused | Proxy host unreachable or port blocked | Test TCP with telnet your-proxy.sparkproxy.com 10000; check firewall |

| ProxyError: Cannot connect to proxy | DNS cannot resolve proxy hostname | Check for typos; try IP address directly instead of hostname |

| ConnectionError: Remote end closed connection | Proxy dropped connection (overloaded or banned IP) | Try a different proxy from your pool |

| SSLError: CERTIFICATE_VERIFY_FAILED | Proxy is intercepting TLS (MITM proxy) | Disable only if you trust the proxy; or use verify=False only for testing |

| curl returns proxy IP, Python returns real IP | HTTP_PROXY or HTTPS_PROXY env var overriding | Run session.trust_env = False to ignore env vars in requests |

| Proxy works from laptop, fails from cloud server | Cloud provider blocks outbound on proxy port | Try port 80, 8080, or 443 — confirm with SparkProxy support which ports are open |

SparkProxy Technical Team — The SparkProxy engineering team builds and maintains global datacenter and residential proxy infrastructure. This guide reflects proxy testing patterns validated with curl 8.x, Python 3.11+, and requests 2.32+ (May 2026).

Citations: httpbin.org — HTTP request and response service · curl man page — proxy options