How to Test If Your Proxy Is Working

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

"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.

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.io:10000")
print(result)
# {"proxy": "http://...", "status": "ok", "exit_ip": "1.2.3.4", "latency_ms": 312, "http_code": 200}

Test multiple proxies in parallel:

from concurrent.futures import ThreadPoolExecutor

PROXIES = [
    "http://your-proxy-1.sparkproxy.io:10000",
    "http://your-proxy-2.sparkproxy.io:10001",
    "http://your-proxy-3.sparkproxy.io: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.

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.io: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.

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.io:10000")
print(result)
# {"proxy": "...", "runs": 5, "success": 5, "avg_ms": 287, "min_ms": 241, "max_ms": 334, "failed": 0}

Latency benchmarks for datacenter proxies:

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.

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.

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.io",
    port=10000,
    username="YOUR_USERNAME",
    password="YOUR_PASSWORD",
)
print(result)

proxy authentication

Common authentication failure causes:

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:

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.io:10000",
    "http://your-proxy-2.sparkproxy.io:10001",
    "http://your-proxy-3.sparkproxy.io:10002",
]

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