Residential Proxy Concurrent Connections: How Many Threads?

What a concurrency limit means

A concurrent-connection (thread) limit is the number of connections a proxy plan lets you hold open at the same time. If a plan allows 50 and you try to open 80, the extra connections are refused or queued, depending on the provider. The limit is about simultaneous connections, not about how many GB or requests you use in total.

Providers state the limit on their plan pages in their own words (threads, sessions, simultaneous connections), so compare the wording and not just the number.

Sizing concurrency from your target rate

Connections in flight = requests per second × average seconds per request. Example numbers for the arithmetic; measure your own response time through the proxy. Add some headroom for retries.

Python: a thread pool through the proxy

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.parse import quote

import requests

user = quote("USERNAME", safe="")
password = quote("PASSWORD", safe="")
proxy = f"http://{user}:{password}@proxy.proxy302.com:2222"
proxies = {"http": proxy, "https": proxy}

WORKERS = 20   # start from your calculation, not from the maximum

def fetch(url):
    started = time.monotonic()
    r = requests.get(url, proxies=proxies, timeout=(5, 20))
    return r.status_code, time.monotonic() - started

urls = ["https://example.com/"] * 200   # replace with your own URLs

with ThreadPoolExecutor(max_workers=WORKERS) as pool:
    futures = [pool.submit(fetch, u) for u in urls]
    for f in as_completed(futures):
        try:
            status, seconds = f.result()
        except requests.RequestException as exc:
            print("error", type(exc).__name__)
        else:
            print(status, round(seconds, 2))

Example only. Replace USERNAME and PASSWORD with the values from My assets. ThreadPoolExecutor(max_workers=N) runs at most N calls at once. Each requests.get opens its own connection, so with a rotating setup a new connection can mean a new IP.

• Sources:
• Python documentation: concurrent.futures

Node.js and other languages

The idea is the same in Node.js: fix the number of requests in flight, and start the next one only when one finishes. The proxy setup for Node.js, including HTTP and SOCKS5, is in the Node.js proxy guide.

Whatever the language, keep a hard upper bound on in-flight requests in code instead of firing everything at once.

• Node.js proxy setup
• Python requests proxy setup

How to raise concurrency safely

1. Step 1

   Start at the number from the table, not at the maximum. Send a few hundred requests and record status codes and times.

2. Step 2

   Double the thread count and repeat. Stop raising it when timeouts, HTTP 429 or 403 responses start to grow: the target is telling you its limit.

3. Step 3

   Back off on 429 and 5xx responses, honour a Retry-After header if the site sends one, and stay within the site's terms and rate limits. More threads do not make a site allow more requests.

Concurrency at Proxy302

The Proxy302 residential lines do not cap concurrent connections, and in a test on 11 November 2026 100 connections open at the same time all worked. This is a statement about the cap, not about speed.

Two practical points. More concurrency spends your GB faster, because traffic is billed per GB whatever the thread count. And without a session, each new connection gets a new IP, so a thread pool that opens many connections will use many IPs; a reused (keep-alive) connection keeps its IP.

• rotating vs sticky sessions

• Sources:
• Proxy302 concurrency test
• Proxy302 product facts and price list

FAQ

Read next

Rotating vs sticky sessions

Three Exit mode options decide whether a residential proxy keeps one IP or changes it; new proxies start on sticky.

Python requests proxy setup

How to use HTTP and SOCKS5 proxies in Python requests: examples, timeouts and an IP check.

Node.js proxy setup

Ways to use an HTTP or SOCKS5 proxy in Node.js, with short examples and an exit check.

How many GB of proxy traffic

Estimate monthly proxy GB from requests and response size: three worked examples, from about 4 GB to about 16 GB a month.