Learn 5 reliable methods to test proxy speed including curl timing, Python scripts, online tools, and our proxy checker. Understand latency vs throughput.

How to Test Proxy Speed — 5 Methods That Actually Work (2026)

A proxy that takes 5 seconds to respond is worse than no proxy at all. Speed testing is essential before you commit proxies to any task — whether that's scraping, account management, or everyday browsing. In this guide, we'll cover five reliable methods to measure proxy performance, from quick command-line checks to automated Python scripts.

Understanding Proxy Speed Metrics

Before testing, you need to understand what "proxy speed" actually means. There are three key metrics:

Latency (Response Time)

The time it takes for a request to travel from your machine, through the proxy, to the destination, and back. Measured in milliseconds (ms).

Excellent: Under 100ms
Good: 100–300ms
Acceptable: 300–800ms
Poor: Over 800ms

Throughput (Bandwidth)

How much data the proxy can transfer per second. Measured in Mbps or MB/s. Important for downloading large files or streaming.

Connection Time

How long it takes to establish the initial connection to the proxy. A high connection time suggests an overloaded or distant proxy server.

Method 1: curl with Timing

The fastest way to test a proxy from the command line. curl has built-in timing variables that give you detailed performance data.

Basic Speed Test

curl -x http://proxy_ip:port -o /dev/null -s -w \
  "Connect: %{time_connect}s\nTTFB: %{time_starttransfer}s\nTotal: %{time_total}s\n" \
  https://httpbin.org/ip

This outputs three timing values:

Connect — Time to establish TCP connection to the proxy
TTFB (Time to First Byte) — Time until the first byte of response arrives
Total — Total request time from start to finish

Testing SOCKS5 Proxies with curl

curl --socks5 proxy_ip:port -o /dev/null -s -w \
  "Connect: %{time_connect}s\nTotal: %{time_total}s\n" \
  https://httpbin.org/ip

Testing with Authentication

curl -x http://username:password@proxy_ip:port -o /dev/null -s -w \
  "Total: %{time_total}s\n" \
  https://httpbin.org/ip

Batch Testing Multiple Proxies

while IFS= read -r proxy; do
  time=$(curl -x "$proxy" -o /dev/null -s -w "%{time_total}" \
    --connect-timeout 5 --max-time 10 \
    https://httpbin.org/ip 2>/dev/null)
  echo "$proxy - ${time}s"
done < proxy_list.txt

Method 2: Python Speed Testing Script

For more control and detailed metrics, use Python. This script tests multiple proxies concurrently and ranks them by speed.

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

def test_proxy_speed(proxy_url, test_url="https://httpbin.org/ip", timeout=10):
    """Test a single proxy and return timing metrics."""
    proxies = {"http": proxy_url, "https": proxy_url}

    try:
        start = time.time()
        response = requests.get(test_url, proxies=proxies, timeout=timeout)
        total_time = time.time() - start

        if response.status_code == 200:
            return {
                "proxy": proxy_url,
                "status": "OK",
                "speed_ms": round(total_time * 1000, 2),
                "response_size": len(response.content),
            }
    except requests.exceptions.Timeout:
        return {"proxy": proxy_url, "status": "TIMEOUT", "speed_ms": None}
    except requests.exceptions.ProxyError:
        return {"proxy": proxy_url, "status": "PROXY_ERROR", "speed_ms": None}
    except Exception as e:
        return {"proxy": proxy_url, "status": f"ERROR: {str(e)}", "speed_ms": None}

def test_all_proxies(proxy_list, max_workers=20):
    """Test all proxies concurrently."""
    results = []

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {
            executor.submit(test_proxy_speed, proxy): proxy
            for proxy in proxy_list
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            speed = result.get("speed_ms", "N/A")
            print(f"  {result['proxy']} — {status} ({speed}ms)")

    # Sort by speed (working proxies first)
    working = [r for r in results if r["speed_ms"] is not None]
    working.sort(key=lambda x: x["speed_ms"])

    return working

# Example usage
proxies = [
    "http://proxy1:8080",
    "http://proxy2:8080",
    "socks5://proxy3:1080",
]

print("Testing proxies...\n")
ranked = test_all_proxies(proxies)
print(f"\nWorking proxies: {len(ranked)}/{len(proxies)}")
print("\nTop 5 fastest:")
for r in ranked[:5]:
    print(f"  {r['proxy']} — {r['speed_ms']}ms")

Method 3: Our Proxy Checker Tool

The easiest method — no code required. Our Proxy Checker tool lets you paste a list of proxies and instantly see:

Response time for each proxy
Anonymity level (transparent, anonymous, elite)
Protocol support (HTTP, SOCKS4, SOCKS5)
Geographic location
Whether the proxy is currently online

Simply visit the tool, paste your proxies (one per line), and click Check. Results appear within seconds.

This is the fastest way to validate proxies you've obtained from any source before using them in your projects.

Method 4: Continuous Monitoring Script

For proxies you use regularly, set up continuous monitoring to catch degradation early.

import requests
import time
import json
from datetime import datetime

def monitor_proxy(proxy_url, interval=300, log_file="proxy_log.json"):
    """Monitor a proxy's speed over time."""
    log = []

    while True:
        try:
            start = time.time()
            response = requests.get(
                "https://httpbin.org/ip",
                proxies={"http": proxy_url, "https": proxy_url},
                timeout=15
            )
            speed = round((time.time() - start) * 1000, 2)

            entry = {
                "timestamp": datetime.now().isoformat(),
                "speed_ms": speed,
                "status": response.status_code
            }
        except Exception as e:
            entry = {
                "timestamp": datetime.now().isoformat(),
                "speed_ms": None,
                "status": str(e)
            }

        log.append(entry)
        print(f"[{entry['timestamp']}] {proxy_url} — {entry['speed_ms']}ms")

        # Save log periodically
        with open(log_file, 'w') as f:
            json.dump(log, f, indent=2)

        time.sleep(interval)

Method 5: Throughput Testing

Speed isn't just about latency. If you're downloading large files or scraping heavy pages, throughput matters too.

import requests
import time

def test_throughput(proxy_url, test_url="https://speed.hetzner.de/1MB.bin"):
    """Test proxy download throughput."""
    proxies = {"http": proxy_url, "https": proxy_url}

    try:
        start = time.time()
        response = requests.get(test_url, proxies=proxies, timeout=30)
        elapsed = time.time() - start

        size_mb = len(response.content) / (1024 * 1024)
        speed_mbps = (size_mb * 8) / elapsed

        print(f"Downloaded {size_mb:.2f} MB in {elapsed:.2f}s")
        print(f"Throughput: {speed_mbps:.2f} Mbps")

        return speed_mbps
    except Exception as e:
        print(f"Throughput test failed: {e}")
        return 0

Interpreting Your Results

What Good Numbers Look Like

Use Case	Target Latency	Min Throughput
Web scraping	Under 500ms	1 Mbps
Sneaker bots	Under 200ms	5 Mbps
Social media mgmt	Under 1000ms	0.5 Mbps
Video streaming	Under 300ms	10 Mbps
General browsing	Under 500ms	2 Mbps

Red Flags

Latency spikes — Inconsistent response times suggest an overloaded proxy
Frequent timeouts — The proxy may be dying or heavily rate-limited
Speed degradation over time — Common with free proxies as more users discover them
Different speeds to different targets — The proxy may be geographically far from certain servers

Tips for Getting the Best Proxy Speeds

Choose geographically close proxies — A proxy in your target site's country will always be faster
Test at different times of day — Proxy speeds vary with usage patterns
Avoid overloaded proxies — If a free proxy is too fast, everyone else found it too
Use our API for fresh proxies — Access validated, speed-tested proxies programmatically via our API
Rotate out slow proxies — Continuously monitor and replace underperformers

Automating Speed Tests with Our API

You can integrate proxy speed testing directly into your workflow using our API:

import requests

# Fetch fresh proxies from IPProxy.site API
api_response = requests.get("https://ipproxy.site/api/proxies?protocol=socks5&limit=20")
proxies = api_response.json()

# Test each proxy
for proxy in proxies:
    result = test_proxy_speed(f"socks5://{proxy['ip']}:{proxy['port']}")
    if result["speed_ms"] and result["speed_ms"] < 500:
        print(f"Fast proxy found: {proxy['ip']}:{proxy['port']} ({result['speed_ms']}ms)")

For a detailed guide on using proxies in Python, check out our tutorial on using proxies with Python requests.

Conclusion

Testing proxy speed isn't optional — it's a fundamental step in any proxy workflow. Use curl for quick one-off checks, Python scripts for batch testing, our Proxy Checker for a no-code solution, and continuous monitoring for long-term proxy management. The best proxy is a fast, reliable proxy, and now you have the tools to find it.