Why are my proxies slow, and how do I fix it?

Speed it up step by step, measure first

1. Time one request with and without the proxy

   Run the curl timing command below twice: direct, then through the gateway. Compare time_connect (reaching the server or proxy), time_appconnect (TLS done), time_starttransfer (first byte) and time_total. If the direct request is slow too, the website is slow. If only the proxied one is slow, read on. In Chrome, DevTools → Network → Timing shows the same phases per request.

2. Count threads: browsers first

   One tab uses about 10 threads. On the 10-thread package that’s the whole plan, so a heavy page like Google Maps, which pulls many tiles and scripts at once, queues behind itself. In DevTools, long Queueing or Stalled bars with short download times mean you’re waiting for connections, not for data. Close tabs, or size the plan for the tabs you actually use.

3. Lower concurrency until speed stops improving

   More threads isn’t always faster. Past your plan’s limit, extra connections fail and get retried, which wastes time. Below the limit, a target site may slow down when it’s hit hard. Run the same job at 10, 20 and 30 workers and keep the number where pages per minute stop rising. That’s your real speed.

4. Spread residential work over ports

   All threads on a residential port share its one IP and that home connection’s upload capacity. Up to 50 threads per port are allowed, but 5 ports with 10 threads each usually move faster than 1 port with 50. Also plan for rotation: every 5 minutes (minute 1, 6, 11 and so on) open connections can drop, so long downloads should resume or retry.

5. Pick a location near the target

   Each extra ocean crossing adds round trips. For US sites use a USA gateway, for European sites an EU one. USA+EU mixes both, and Worldwide spreads exits further, which is useful for scraping coverage but can be slower for a single regional site. Run your scraper close to the gateway region too; a server in Asia talking to a USA gateway adds distance before the proxy even starts.

6. Set timeouts that fail fast

   Without a timeout, one dead connection can hold a worker for minutes. Use a short connect timeout (around 10 seconds) and a longer read timeout (around 30), then retry on a new connection. On residential, retrying after a rotation drop is expected, not a sign of trouble.

7. Stop downloading what you don’t need

   In headless browsers, block images, fonts and media when you only need text or data, and wait for domcontentloaded instead of every last request. For plain HTTP clients, request only the pages you parse and keep compression on. Fewer requests per page also means fewer threads used.

8. Still slow? Give support the numbers

   Send your username, the gateway you use, the target site, your software, and the exact error or the curl timing output for one slow request via the contact page. Timings for a direct and a proxied request side by side show us where to look.

Measure and trim

Replace GATEWAY_IP:PORT with your gateway. Run the timing check from the machine that runs your tool.

FMT='connect:%{time_connect}  tls:%{time_appconnect}  first-byte:%{time_starttransfer}  total:%{time_total}\n'

# direct
curl -s -o /dev/null -w "$FMT" https://www.example.com/

# through the proxy
curl -s -o /dev/null -w "$FMT" -x http://GATEWAY_IP:PORT https://www.example.com/

# big first-byte gap in both  -> the site is slow
# big gap only via proxy      -> threads, distance or a busy residential port

from playwright.sync_api import sync_playwright

SKIP = {"image", "font", "media"}

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={"server": "http://GATEWAY_IP:PORT"})
    page = browser.new_page()
    page.route("**/*", lambda route: route.abort()
               if route.request.resource_type in SKIP else route.continue_())
    page.goto("https://www.example.com/", wait_until="domcontentloaded", timeout=45000)
    print(page.title())
    browser.close()

import time, requests
from concurrent.futures import ThreadPoolExecutor

PROXY = "http://GATEWAY_IP:PORT"
URLS = ["https://www.example.com/"] * 60      # use real pages from your job

def get(u):
    try:
        return requests.get(u, proxies={"http": PROXY, "https": PROXY},
                            timeout=(10, 30)).status_code
    except requests.RequestException:
        return None

for workers in (5, 10, 20, 30):              # stay at or below your plan
    t = time.time()
    with ThreadPoolExecutor(max_workers=workers) as ex:
        ok = sum(1 for c in ex.map(get, URLS) if c == 200)
    print(f"{workers:>2} workers: {ok}/{len(URLS)} ok, {len(URLS)/(time.time()-t):.1f} pages/s")

Reading the timing numbers

Thread math for browsers and Google Maps

Residential speed: what to expect

Connection reuse: faster, but watch rotation

Common errors and fixes

FAQ

Still have questions? Contact us here. A real person answers.

Related guides

Tool facts checked against the official documentation (October 2026): Chrome DevTools: Network reference (Timing) · curl man page (--write-out) · Playwright: Network (route) · Requests: Timeouts. Storm Proxies facts: our plans page and refund policy.