Home / Guides / How many proxies?

How many proxies do I need?

Count what runs at the same moment, not how many pages you fetch. On rotating proxies, threads ≈ requests per second × seconds per request, plus about 10 threads per browser tab. On residential, buy one port for every IP you need at once. On dedicated, one proxy per account or identity.

Updated October 2026Choosing & buying

“How many proxies do I need?” is the question behind most wrong orders we see. Someone buys the 10-thread package for a job that opens four browser tabs, gets connection errors and decides the proxies are “not working”. Someone else buys 200 threads for a script that only ever runs 15 requests in parallel. Both paid for the wrong number because they counted pages or IPs instead of simultaneous connections.

The answer also depends on the proxy type, because each one is sold by a different unit. Rotating datacenter plans are sold by threads (open connections), residential plans by ports (one exit IP each at a time), and dedicated plans by proxies (one fixed IP each). The same job can need 40 of one unit and 5 of another.

This page gives you the formula, then works through the jobs our customers actually run: scraping a set number of pages a day, tracking keyword rankings on Google, running browser automation, holding several residential sessions and managing accounts. For the theory behind threads, read proxy threads explained; this page is about the numbers.

Which Storm plan fits

Most scraping and rank-tracking jobs fit a rotating plan of 40 or 80 threads: every connection on the Main gateway gets a new IP, so you size by concurrency, never by IP count or gigabytes. Pick residential when a target treats datacenter IPs harshly and you need a set number of distinct home IPs at once (one per port). Pick dedicated only when each account must keep the same IP for months.

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 plans

Before 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).

On this page

Size your plan in six steps
A sizing calculator you can run
Worked examples: rotating proxies (sold by thread)
Worked example: Google rank tracking and SERP scraping
Worked example: browser tools and automation
Worked example: residential ports (one IP each)
Worked example: dedicated proxies for accounts
Signs you picked the wrong size
Common errors and fixes
FAQ

Size your plan in six steps

Write down the job in one sentence
For example: “Fetch 300,000 product pages every night between 1 am and 7 am” or “Check 5,000 keywords on Google once a day”. A time window matters more than a daily total, because the same pages squeezed into 6 hours need four times the concurrency of 24 hours.
Time one real request
Fetch a handful of pages from your actual target through any proxy and note how long each takes from start to finish. Use the average. Plain HTML from a fast site might take 1 to 2 seconds; heavy pages, retries and polite delays push it to 3 to 5.
Turn the goal into requests per second
Divide the requests by the seconds in your window. 300,000 pages in 6 hours (21,600 seconds) is about 14 requests per second. Count retries too: if one in ten requests is repeated, multiply by 1.1.
Multiply by seconds per request
Concurrency = requests per second × seconds per request. 14 per second at 2.5 seconds each means about 35 connections open at once. That is your thread count for rotating proxies.
Add browsers and other tools on the same plan
Every tool that uses the same plan shares the limit. Add roughly 10 threads per open browser tab, plus whatever your other scripts run. Search-engine work also has its own ceiling: at most a quarter of your threads, on the Main gateway.
Round up to the next plan and keep a margin
Rotating plans come in 10 (test), 40, 80, 150 and 200 threads. Pick the first one that covers your total plus 10 to 20 percent headroom. If you land just over a plan size, cutting concurrency a little is usually cheaper than the next size up.

A sizing calculator you can run

Change the numbers at the top to your job. It prints the concurrency you need and the smallest rotating plan that covers it, including the 25% search-engine ceiling.

Python: threads for a job

import math

PAGES          = 300_000   # requests in one run
WINDOW_HOURS   = 6         # how long the run may take
SEC_PER_REQ    = 2.5       # measured average, including waits
RETRY_FACTOR   = 1.1       # 10% of requests are retried
BROWSER_TABS   = 0         # tabs open on the same plan (about 10 threads each)
SEARCH_ENGINE  = False     # True if the target is Google, Bing etc.

rps = PAGES * RETRY_FACTOR / (WINDOW_HOURS * 3600)
threads = math.ceil(rps * SEC_PER_REQ) + BROWSER_TABS * 10
if SEARCH_ENGINE:
    threads *= 4           # search work may use only 25% of the plan
threads = math.ceil(threads * 1.15)   # 15% headroom

plans = [10, 40, 80, 150, 200]
fit = next((p for p in plans if p >= threads), None)
print(f"{rps:.1f} req/s -> about {threads} threads -> plan: {fit or 'more than 200, split the job or ask support'}")

Worked examples: rotating proxies (sold by thread)

All examples use the Main gateway, which gives a new IP on every new connection from a pool of 700,000+. Times are typical for plain HTTP scraping; measure your own.

50,000 pages a day, spread over 24 hours, 2 seconds each. 50,000 ÷ 86,400 = 0.6 requests per second × 2 = about 2 threads. The 10-thread package at $14/mo covers it with room to spare. This is the one case where the test package is enough for real work.
500,000 pages a day over 24 hours, 3 seconds each. 5.8 per second × 3 = about 18 threads, 21 with headroom. The 40-thread plan at $39/mo, with spare threads for a browser tab or a second script.
300,000 pages in a 6-hour night window, 2.5 seconds each. About 14 per second × 2.5 = 35, plus headroom = 40. That is the very top of the 40-thread plan; take 80 threads at $59/mo if you can’t stretch the window.
2 million pages a day, 3 seconds each. 23 per second × 3 = 70 threads, about 80 with headroom. The 80-thread plan at $59/mo is tight; 150 threads at $97/mo gives breathing room for retries and slow days.

Bandwidth is unlimited on every plan, so heavy pages change the thread count only through the time they take, never through a data bill. See rotating proxy plans for what each size includes.

Worked example: Google rank tracking and SERP scraping

Search engines are the strictest common target, so two rules apply: use the Main gateway (not the 3-minute one), and send search traffic through at most 25% of your plan’s threads. The rest of the plan can do other work.

2,000 keywords a day, one results page each, 5 seconds per request including pauses. Over a 4-hour window that is 0.14 per second × 5 = under 1 thread. Even so, keep search to a quarter of the plan: the 40-thread plan ($39/mo) allows 10 search threads, far more than you need, and leaves 30 for checking your own site or competitors.
20,000 keywords, two pages each, in 8 hours, 5 seconds each. 40,000 requests ÷ 28,800 seconds = 1.4 per second × 5 = 7 threads. Inside the 10 search threads of a 40-thread plan.
100,000 keywords a day, one page each, 5 seconds, 12-hour window. 2.3 per second × 5 = about 12 threads, 14 with headroom. At 25%, that needs a plan of at least 56 threads: the 80-thread plan ($59/mo) gives you 20 search threads.

If you see more CAPTCHAs as you scale, add time between queries before you add threads. Running more connections at Google than the 25% ceiling raises block rates faster than it raises output. Tool-specific setups are in the ScrapeBox guide.

Worked example: browser tools and automation

A browser doesn’t open one connection per page. It opens several per site for HTML, scripts, images and fonts, and keeps them alive. Plan for about 10 threads per open tab, whether the browser is Chrome, a Playwright or Puppeteer script, Selenium or an AI browser agent.

One tab for checking results by hand: about 10 threads. The 10-thread package is fully used, so it’s only good for testing.
Three headless pages in Playwright: about 30 threads. The 40-thread plan.
Google Maps or another heavy map or listing site in 6 tabs: about 60 threads, and these pages load many map tiles and scripts. The 80-thread plan. If pages crawl, it is usually because the tabs are competing for too few threads, not because the IPs are slow.
12 parallel browser workers: about 120 threads. The 150-thread plan.

To cut thread use per tab, block images, fonts and media you don’t need. The Playwright guide shows how.

Worked example: residential ports (one IP each)

Residential plans count ports. Each port is one gateway IP:PORT that exits through one home IP at a time. That IP changes every 5 minutes at fixed times (minute 1, 6, 11, 16 and so on of each hour). A port allows up to 50 threads, but all of them share that port’s current IP.

You need 5 separate sessions at once, each looking like a different visitor: 5 ports ($50/mo).
You scrape a retail site that limits each IP to a few requests a minute and want 10 workers that never share an IP: 10 ports ($90/mo), one worker per port.
25 workers with distinct IPs: there is no 25-port plan, so either take 20 ports ($160/mo) and cap at 20 workers, or take 50 ports ($300/mo) and grow into it.

Rule of thumb: ports = IPs you need at the same moment; threads per port = how hard you can push each IP before the site objects. Compare plans on the residential proxy page.

Worked example: dedicated proxies for accounts

Private dedicated proxies are static USA IPs used only by you, at $2 per proxy, from 5 for $10/mo up to 400 for $640/mo. Each one allows 100 concurrent threads, so threads are rarely the limit; the count you need is the number of identities.

Managing 5 store or social accounts, each always seen from the same IP: 5 proxies, one per account.
Managing 40 accounts: 40 or more proxies. Don’t put several accounts on one IP to save money; that is exactly the link between accounts you were trying to avoid.
A scraper that needs a fixed IP for an allow-listed API: often a single proxy is enough, and user:pass authentication lets it run from cloud servers whose IP changes.

If you don’t need the same IP every day, rotating or residential will give you far more IPs for the money. See rotating vs static proxies to decide.

Signs you picked the wrong size

Too small: errors appear only when you raise concurrency or open a second tool; a single run is clean at 30 workers and noisy at 60; browser pages hang half loaded. Lower concurrency to confirm, then upgrade. In the member area you can move to a bigger plan in one click; the unused part of your current plan is credited and the old plan stops automatically.

Too big: your tools never reach the thread limit even at their busiest hour. Move to a smaller plan the same way. If you’re unsure where you are, start with the smallest package of the type you need, measure, and resize; that is also the package covered by the 24-hour money-back guarantee on your first order.

Common errors and fixes

Connection resets or timeouts start when a second script startsBoth tools share one thread limit. Add their concurrency together and lower it to fit your plan, or upgrade.

More CAPTCHAs on Google after adding threadsSearch traffic is above 25% of the plan. Cap search threads at a quarter of your plan, keep it on the Main gateway, and space queries out.

Residential workers get blocked togetherSeveral workers share one port, so the site sees one busy visitor. Spread workers across more ports, or slow down per port.

FAQ

Is one proxy enough for web scraping?

One static IP is enough only for light, slow jobs on lenient sites. For anything regular, a rotating gateway is the better “one proxy”: a single IP:PORT that gives a new IP per connection, so 40 threads can mean 40 different IPs at the same moment.

How many IPs do I get with a 40-thread rotating plan?

Up to 40 different IPs at any one moment, and far more over a day, because each new connection on the Main gateway draws from the 700,000+ pool. The plan limits concurrency, not the number of IPs you see.

How many threads does a Storm residential port allow?

Up to 50 threads per port. All of them use the port’s current IP, which changes every 5 minutes. For many distinct IPs at once, add ports rather than threads.

Should I buy more threads or more residential ports?

More threads if the target accepts datacenter IPs and you need volume: it’s cheaper per connection. More residential ports if the target blocks datacenter ranges or limits each IP tightly, because each port adds a separate home IP.

Can I change plan size later on Storm Proxies?

Yes. In the member area you can upgrade or move to a smaller plan in one click. The unused part of the current plan is credited and the old plan stops automatically, so there’s no penalty for starting small.

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

Tool facts checked against the official documentation (October 2026): Python docs: math.ceil. 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.

Get 40 threads for $39/mo Compare all plans