What are proxy threads, and how many do you need?
A proxy thread is one connection open through the proxy at the same moment. A 40-thread plan lets you have 40 connections in flight at once, across all your tools and machines. Threads are not IPs, not ports and not requests per day: how many requests you finish depends on how long each one takes.
“Threads” is the word proxy sellers borrowed from software: a program runs several workers in parallel, and each worker holds one connection. On the proxy side, what is actually counted is simultaneous connections through the gateway. Whether your program uses operating-system threads, async tasks or browser tabs doesn’t matter; what matters is how many sockets are open to the proxy at the same moment.
People run into thread limits in two ways. Either they buy a plan sized by pages (“I scrape 50,000 pages a day, so 10 threads is plenty”) and then open a browser that uses dozens of connections on its own, or they set a scraper to 200 workers on a 40-thread plan and see a wall of connection errors that looks like an outage.
This guide separates the four numbers people confuse, shows how to count threads in the tools you actually use, explains what happens when you exceed the limit, and gives a simple way to size a plan.
Which Storm plan fits
Storm rotating proxies are sold by thread: 10 threads for testing, then 40, 80, 150 and 200. Pick the size from your concurrency, not your page count, since bandwidth is unlimited. Residential is sold by port (one IP each, up to 50 threads per port) and dedicated by proxy (100 threads each), so on those the limit you’ll meet first is usually IPs, not threads.
Rotating proxies (from $14/mo): 700,000+ IPs behind fixed gateway IP:PORTs. New IP on every request, or every 3 or 15 minutes. USA, EU, USA+EU or Worldwide. Unlimited bandwidth on every plan.
Get 40 threads for $39/mo See all rotating proxies plansBefore you start
- Log in to the member area and copy your gateway
IP:PORTs. They never change; the rotation happens on our side. - Add the public IP of the computer or server that will run your tool under Authorized IPs, click Save, and allow up to 15 minutes before testing. Rotating and residential proxies use IP authentication, so there is no username or password.
- Dedicated proxies work with either IP authentication or a username and password. Use user:pass if your IP changes or the tool runs on several machines.
- Count your threads: the tool’s total open connections must stay within your plan (for example 40 threads on the 40-thread plan).
How to size a plan by threads
- Measure how long one request takes
Time a few real requests to your target through the proxy, from start to full response. Plain HTML fetches often take 1 to 3 seconds; a full browser page load can take 5 to 15. Use the average, not the best case.
- Decide how fast you need to go
Turn your goal into requests per second. 100,000 pages in 8 hours is about 3.5 requests per second. 1 million pages a day is about 11.6 per second.
- Multiply to get threads
Threads needed ≈ requests per second × seconds per request. At 3.5 per second and 2 seconds each, you need about 7 threads. At 11.6 per second and 3 seconds each, about 35.
- Add every other tool on the same plan
The limit is shared. A scraper with 30 workers plus a browser with two tabs (around 20 connections) is already 50 threads. Write the total down.
- Keep a margin and respect target limits
Leave 10 to 20 percent headroom for retries and slow pages. If part of the job is search engines, that part should use at most a quarter of your threads on the Main gateway.
- Set the number in every tool
Put the per-tool share into each tool’s concurrency setting so the sum stays within your plan. The examples below show where that setting lives in common tools.
Where to set concurrency in common tools
In each example the number is the maximum open connections that tool will create. Keep the sum across all tools at or below your plan’s threads.
# Scrapy's own default for CONCURRENT_REQUESTS is 16
CONCURRENT_REQUESTS = 32 # total in flight; your share of a 40-thread plan
CONCURRENT_REQUESTS_PER_DOMAIN = 8 # don't hammer one site with all 32
DOWNLOAD_DELAY = 0.5 # seconds between requests to the same domain
AUTOTHROTTLE_ENABLED = True # backs off when the site slows downfrom concurrent.futures import ThreadPoolExecutor
THREADS = 40 # plan limit; the executor's default is min(32, CPUs + 4)
with ThreadPoolExecutor(max_workers=THREADS) as pool:
results = list(pool.map(fetch, urls))import aiohttp, asyncio
async def main(urls):
conn = aiohttp.TCPConnector(limit=40) # aiohttp's default limit is 100
async with aiohttp.ClientSession(connector=conn) as s:
async def get(u):
async with s.get(u, proxy="http://GATEWAY_IP:PORT") as r:
return r.status
return await asyncio.gather(*(get(u) for u in urls))// run at most 40 requests at a time
const LIMIT = 40;
async function runAll(urls, worker) {
const out = [];
let i = 0;
const lanes = Array.from({ length: LIMIT }, async () => {
while (i < urls.length) { const u = urls[i++]; out.push(await worker(u)); }
});
await Promise.all(lanes);
return out;
}Threads, IPs, ports and requests per second
These four numbers describe different things, and mixing them up is the root of most sizing mistakes.
- Threads are simultaneous connections. They control how much work runs in parallel.
- IPs are the exit addresses websites see. On a rotating gateway, many threads can each get a different IP; on a residential port, all threads share the port’s single current IP; on a dedicated proxy, all threads share one fixed IP.
- Ports are gateway entry points (
IP:PORT). On Storm rotating plans, a plan includes a number of gateway ports and the thread limit covers all of them together. On residential, each port is one IP at a time with up to 50 threads. - Requests per second is the outcome: threads divided by seconds per request. It isn’t a limit Storm sets, and bandwidth isn’t either; the same 40 threads can do far more work against a fast API than against a slow, heavy page.
So “how many IPs do I get with 40 threads?” on a rotating plan has two answers: up to 40 different IPs at the same moment, and many more over a day, because each new connection on the Main gateway draws a fresh IP from a pool of 700,000+.
How many threads common tools use
Browsers. A browser opens several connections per page: one per host for HTML, scripts, images, fonts and trackers, kept alive for reuse. Chromium’s network stack has historically capped this at 6 per host and 32 per proxy server. In practice one tab uses around 10 threads through the proxy, so a 10-thread package is fully used by a single tab. Browser tools such as Playwright, Puppeteer and Selenium follow the same rule: count tabs or pages, not scripts.
Scrapy. CONCURRENT_REQUESTS (16 by default) is the global cap; CONCURRENT_REQUESTS_PER_DOMAIN limits each site. The global number is what to compare with your plan. See the Scrapy proxy guide for the full setup.
Python requests with a thread pool. max_workers is your thread count. Without one, ThreadPoolExecutor picks a default based on CPU count, which may be higher or lower than your plan.
aiohttp and other async clients. The connector’s limit is the cap. aiohttp defaults to 100, which is more than a 40- or 80-thread plan allows, so set it explicitly.
ScrapeBox. The harvester and each add-on have their own connection setting, and they add up when several run at once. Search-engine harvesting should use the Main gateway and at most a quarter of your threads. ScrapeBox’s built-in proxy checker isn’t compatible with Storm gateways; the proxies still work for harvesting, so check them in a browser. More in the ScrapeBox guide.
What happens when you go over the limit
Extra connections don’t queue politely. They fail, and your tool reports what it sees: a reset or dropped connection, a proxy connection failure in the browser, or timeouts. Because the first 40 connections keep working, the errors look random, which is why people often read them as a proxy outage.
Signs you’re over the limit:
- Errors start when you raise concurrency and stop when you lower it.
- Errors appear when a second script or a browser starts using the same plan.
- A single run is clean at 30 workers and noisy at 60.
The fix is to lower concurrency in every tool until the total fits, or to move to a bigger plan. Raising timeouts or adding retries without lowering concurrency only adds more connections.
Sizing examples
- Price checks, 20,000 product pages twice a day with requests: about 2 seconds per page, finished within 2 hours each run. That’s roughly 2.8 pages per second, so 6 threads; a 10-thread package covers it with room for retries.
- Scrapy crawl of 1 million pages a day: 11.6 pages per second at 3 seconds each is about 35 threads. A 40-thread plan ($39) fits if nothing else runs on it; 80 threads ($59) leaves room.
- Playwright running 8 tabs: about 80 threads. The 80-thread plan is tight; 150 threads ($97) is comfortable.
- SEO rank tracking: if search queries need 20 threads, a quarter rule means an 80-thread plan.
- 20 accounts that each need their own IP: threads aren’t the constraint here. Use 20 dedicated proxies, or 20 residential ports if home IPs and a 5-minute change suit the task.
Since traffic isn’t billed, you never need extra threads to cover large pages. You only need them for more parallel work. The unlimited bandwidth guide covers the traffic side.
More threads isn’t always faster
Past a point, adding threads makes a job slower. The target site starts returning 429s or slowing its responses, each request takes longer, and your requests per second stop rising. Watch the ratio of successful responses as you scale up, and cap per-site concurrency even when your plan allows more. A crawl across many sites can use all your threads; a crawl of one site usually shouldn’t.
Common errors and fixes
ERR_PROXY_CONNECTION_FAILED on some page loadsA tab plus a running scraper used up the threads. Pause the scraper or give the browser a larger share. See the full fix.CONCURRENT_REQUESTS is above your plan or the site slows down under load. Lower it, set a per-domain limit and enable AutoThrottle.FAQ
What is a thread in proxies?
One connection open through the proxy at a given moment. A plan with 40 threads allows 40 simultaneous connections in total.
Is one thread the same as one IP?
No. On a rotating gateway each new connection can get a different IP, so 40 threads can mean 40 IPs at once and thousands over a day. On a residential port or a dedicated proxy, all threads share one IP.
How many threads does a browser use with a proxy?
Around 10 per open tab, because a page loads resources over several connections at once. Plan browser automation by tabs times ten.
Are Storm thread limits per machine or per plan?
Per plan. Every script, browser and server that uses the plan shares the same thread count, whichever gateway port it connects to.
Does a bigger Storm plan mean more bandwidth?
No, bandwidth is unlimited on every plan. A bigger plan gives you more threads, so more requests can run at the same time.
Is the 10-thread package enough to start?
For testing a scraper, yes. For browser-based tools it’s too small, since one tab uses about 10 threads. Move to 40 threads or more for real workloads.
Still have questions? Contact us here. A real person answers.
Related guides
Tool facts checked against the official documentation (October 2026): Scrapy settings: CONCURRENT_REQUESTS · Scrapy AutoThrottle · Python concurrent.futures: ThreadPoolExecutor · aiohttp client reference: TCPConnector · Chromium network stack design. Storm Proxies facts: our plans page and refund policy.
Unlimited bandwidth. One flat monthly price.
Access is live the moment you pay, and the smallest package of each proxy type has a 24-hour money-back guarantee on your first order.