How Many Proxies Do I Need? Sizing Formulas and Real Page-Weight Data

How many proxies you need depends on one thing: whether your work is tied to an identity or to volume. If you manage accounts that each need their own network identity, our starting recommendation is one dedicated static IP per account, plus about 10% spare. If you collect public data, you size by request rate: divide your requests per minute by the rate one IP can safely send to that site, then add a 25% buffer. With a rotating residential pool you buy gigabytes instead of a fixed IP list, and our measurements below show 1,000 pages can cost anything from about 2 MB to over 2 GB.

This guide gives you the formulas, the per-workload rules of thumb, real page-weight numbers we measured on 29 October 2026, and a short Python script that does the math for you.

TL;DR

• Accounts with their own identity: start with 1 static ISP IP per account, never shared between accounts. Add 10% spare. CleanProxies ISP proxies are 100% dedicated, unlimited bandwidth and unlimited threads, as low as $0.75/IP.

• Scraping one site at a steady rate: IPs = requests per minute ÷ safe requests per IP per minute × 1.25.

• Scraping many sites or at large scale: use rotating residential and budget GB: GB = pages × KB per page ÷ 1,000,000 × 1.15. CleanProxies rotating residential is as low as $0.63/GB, and the data never expires.

• How you fetch matters more than how many IPs you have: in our test, a plain compressed HTML fetch used about 33× less data than loading the same page in a full browser.

• Not sure yet? Run the numbers in the proxy cost calculator, then test for real with the $4.99 trial (5 ISP IPs for 1 hour, or 100 MB).

Quick sizing table

Why "how many proxies" is really two different questions

There are two ways proxies are sold, and they answer the question differently.

Per IP (static ISP and subnet proxies). You get a fixed list of IPs that stay the same all month. The number of IPs is the thing you buy, so the count matters. CleanProxies ISP proxies are priced per IP per month with unlimited bandwidth and unlimited threads, so once you have the right number of IPs you never pay more for heavy use.

Per GB (rotating residential and mobile proxies). You connect to one gateway and get a new IP from a large pool on each request, or keep one IP for a sticky session. The pool behind CleanProxies rotating residential has 50M+ IPs in 190+ countries. You don't buy a fixed IP list, you buy data, so the budgeting question becomes "how many GB do I need?" You still plan the request rate (Rule 3 shows how), because the target site sees how many requests arrive per minute, not how many GB you bought.

If you only remember one thing: identity work → count IPs; volume work → plan the request rate, then budget gigabytes. For a deeper look at the session side, see rotating vs sticky sessions.

Rule 1: one IP per account

Our conservative starting recommendation for accounts that need separate network identities is a 1:1 mapping between accounts and IPs: one account always uses the same IP, and no IP is shared between two accounts. That matches how a real person looks: same home connection, day after day.

This is about a persistent account identity. A short multi-step job (for example a checkout test on your own store or a paginated search) only needs the same IP for minutes, and a sticky session on rotating residential or mobile proxies covers that, with sessions up to 24 hours.

• Static ISP proxies are the right tool here because the IP stays the same for the whole month and sits on a real US carrier ASN.

• Keep about 10% spare IPs for new accounts, so you never have to put two accounts on one IP.

• Don't rotate logged-in sessions. Changing IP mid-session is one of the common proxy mistakes that cause bans.

• One task per IP for logged-in work. Here a "task" means one account session running at a time. ProxyRack's guide suggests "1 proxy per task or at most 3 tasks per proxy" (source). For accounts we recommend the stricter end: one.

Example. A social media agency manages 40 brand accounts for clients. It needs 40 IPs, plus 4 spare: 44 static ISP IPs. Because CleanProxies IPs are 100% dedicated and never shared with another customer, nobody else's activity lands on those accounts.

Only use accounts you own or are authorised to manage, and follow each platform's terms.

Rule 2: size scraping by request rate

For data collection, the limit is how fast one IP can send requests to one site before it starts seeing 429 "Too Many Requests" responses, CAPTCHAs or blocks. That "safe rate" is different for every site, so treat any starting number as a guess and measure it.

The formula:

IPs needed = (requests per minute) ÷ (safe requests per IP per minute) × 1.25

Use your peak requests per minute if traffic is bursty. If you pace requests evenly, the average rate inside your collection window is the same thing, which is what the example below assumes. The 1.25 is a starting buffer for retries, slow IPs and spikes; adjust it once you have real data. Count requests, not pages: pagination, retries and every extra call a browser makes all add requests.

Example. You need 100,000 product pages a day from one retailer, collected within an 8-hour window.

1. 100,000 ÷ 8 hours = 12,500 requests per hour = about 208 requests per minute.

2. Start with a polite assumption of 6 requests per minute per IP (one every 10 seconds). This is a starting guess to test, not a rule for every site.

3. 208 ÷ 6 = 35 IPs, × 1.25 = about 44 static IPs.

If you can spread the same job over 24 hours, the peak rate drops to about 69 per minute and you need roughly a third as many IPs. Spreading the schedule is the cheapest way to need fewer proxies.

During our own test (below), Hacker News started answering with a 503 Service Unavailable after a handful of back-to-back requests from one IP. A 503 can mean throttling, overload or maintenance, so we can't say which it was. Either way, the right response is the same: back off, respect any Retry-After header, and pace requests instead of hammering one address.

A second rule of thumb. Apify's help centre uses a heuristic per target domain: take the pages, divide by 10,000 if the scrape is spread over a month, 1,000 if it must finish within a day or 100 within an hour; then multiply by 1, 10 or 100 for a monthly, daily or hourly repeat, and by 10 again for very popular sites (source). Its own example: 10,000 pages, scraped once a month and finished within a day, comes to 10 IPs. It's a useful sanity check against your request-rate number.

Rule 3: size rotating proxies by gigabytes

When you scrape many sites, or volume is huge, a rotating residential pool is simpler: every request can come from a different IP, so you don't manage an IP list. You plan two things: the request rate and the data budget.

GB needed = pages × KB per page ÷ 1,000,000 × 1.15

Here 1 GB = 1,000,000 KB. Our page weights below already include response headers, so the 1.15 is an adjustable contingency for retries, redirects and pages heavier than your sample.

Rate first, then GB. Take the 100,000-pages-a-day job from Rule 2 and run it on rotating residential instead. The rate is still about 208 requests per minute, but with a fresh IP on each request no single address carries more than a few of them, so you don't need to hold 44 IPs of your own. You do need enough IPs in the geography you target: a US-wide job draws on a far bigger slice of the pool than a single small city. The data budget is 100,000 × 65 KB ÷ 1,000,000 = 6.5 GB a day, about 195 GB a month before contingency, or about 224 GB after it.

Page weight is the number most guides skip, so we measured it.

Our test: how much data does one page really use?

Method. On 29 October 2026 we fetched each public page below three times with curl from a US server, directly (no proxy), with a desktop Chrome user agent and Accept-Encoding: gzip, br, following redirects. We recorded the compressed body size plus the response header size (curl's size_download + size_header, HTTP/1.1-style headers) and kept the median of the runs that returned 200 (all three for every page except Hacker News, where later runs returned 503). For the browser rows we loaded the page in a fresh, empty-cache headless Chromium (Playwright), waited for the load event plus 4 seconds, and summed the body and header bytes of every finished request, with and without images, fonts and stylesheets blocked. These are HTTP-level numbers: your provider's billed traffic can differ slightly because of TLS and connection overhead. We left out one retailer page because it returned a bot-check page instead of the real content.

What the numbers mean:

• The same GitHub page cost 66 KB as HTML and 2.2 MB in a browser: about 33× more data. If you can parse the HTML or call a JSON endpoint, you need a fraction of the GB.

• Blocking images, fonts and stylesheets cut the browser load by 57% (2.2 MB → 0.94 MB). If you must render JavaScript, block what you don't need.

• Compression is huge. Asking for gzip/brotli shrank the HTML by 74–85% (for example, the BBC page went from 389 KB raw to 65 KB on the wire). Always send Accept-Encoding.

• Headers matter on small responses. On the Wikipedia summary API, headers were 77% of the bytes. Tiny API calls are cheap but not free.

• Most real pages are far heavier than the toy sites. The HTTP Archive Web Almanac 2025 puts the median inner page at about 2.0 MB on desktop and 1.8 MB on mobile, while the median HTML document alone is only 35 KB (source). A browser-based scraper pays for the whole page; an HTML scraper pays for the HTML.

Worked examples

These examples use 65 KB (close to our heavier HTML pages) and 2.2 MB (our full GitHub load) as illustrative page weights. Measure your own targets before you buy.

1. Price monitoring, 20,000 products twice a day (HTML only). 40,000 pages a day × 65 KB = 2.6 GB a day, about 78 GB a month, × 1.15 ≈ 90 GB a month of rotating residential. Because CleanProxies GB never expires, you can buy a larger pack at a lower per-GB rate and use it over several months. See price aggregation for the full setup.

2. The same job in a full browser. 40,000 pages × 2.2 MB = 88 GB a day, about 2,640 GB a month, × 1.15 ≈ 3,036 GB a month. That is about 34× the data of example 1 (78 vs 2,640 GB before contingency), for the same products. Switch to HTML or block assets before you scale.

3. SEO rank tracking. 2,000 keywords × 3 cities × 1 check a day = 6,000 requests a day, 180,000 a month. Multiply by your measured page weight (use the script below on one of your own result pages). Rotating residential supports city and state targeting, which local rank tracking needs. More on the SEO use case.

4. A 1,000-IP static fleet. A team running steady, high-volume jobs on fixed US IPs needs 1,000 static IPs. On the standard CleanProxies ISP tiers that is $0.99/IP, $990 a month, with unlimited bandwidth, so heavy traffic adds nothing to the bill, and the standard tier drops to $0.75/IP at 10,000 IPs (AT&T IPs have their own price ladder; ISP IPs are chosen by carrier, not by city or state). For very large orders, check live availability with support before you plan around a single carrier. Only if you need contiguous ranges, ISP subnets come in /24 blocks of 255, 510 or 1,020 IPs, from $1.19/IP at 1,020.

A script that does the math

Measure a few of your target pages through your proxy, then plug the result into the sizing functions. Replace USER:PASS@HOST:PORT with the details from your CleanProxies dashboard.

# Prints: HTTP status, compressed body bytes, header bytes
curl -s -L -o /dev/null \
  -x "http://USER:PASS@HOST:PORT" \
  -H "Accept-Encoding: gzip, br" \
  -w "%{http_code} %{size_download} %{size_header}\n" \
  "https://example.com/your-target-page"

Your page weight in KB is (body bytes + header bytes) ÷ 1,000. Only use samples with a 200 status; an error or challenge page is not a real page and will skew the average. This measures one HTTP fetch. If your scraper renders pages in a browser, measure in the browser instead: in Chrome DevTools open the Network tab, tick Disable cache, reload, and read the transferred total at the bottom, or sum request.sizes() for every finished request in Playwright.

import math

def static_ips_needed(requests_per_day, window_hours, safe_rpm_per_ip, buffer=1.25):
    """Static IPs for one target site. Assumes requests are paced evenly
    across the window; pass your peak rate instead if traffic is bursty."""
    rpm = requests_per_day / (window_hours * 60)
    return math.ceil(rpm / safe_rpm_per_ip * buffer)

def accounts_ips_needed(accounts, spare=0.10):
    """One dedicated IP per account, plus spare."""
    return math.ceil(accounts * (1 + spare))

def gb_per_month(pages_per_day, kb_per_page, contingency=1.15, days=30):
    """Rotating residential or mobile data, sized by page weight (1 GB = 1,000,000 KB)."""
    return round(pages_per_day * kb_per_page * days * contingency / 1_000_000, 1)

print(static_ips_needed(100_000, 8, 6))   # 44
print(accounts_ips_needed(40))            # 44
print(gb_per_month(40_000, 65))           # 89.7

Then open the proxy cost calculator to see the exact price for your quantity, and the saving at the next tier.

Which product should you size for?

Most teams end up with a mix: a static ISP fleet for identity work and a rotating residential balance for bulk collection. Compare every option on the compare page.

Why CleanProxies for any size

Whatever number you land on, CleanProxies is built so the count you buy is the count that works:

• The cleanest ISP IPs: 0 fraud score, super clean ranges on Tier-1 US carrier ASNs. See our US locations.

• 100% dedicated: your static IPs are never shared with another customer.

• Speed: 100Gbps network ports, <20ms latency and 99.9% uptime.

• No caps on ISP: unlimited bandwidth and unlimited threads, so you size by IPs only.

• Instant delivery: proxies go live seconds after payment.

• The cheapest pricing in the market: ISP as low as $0.75/IP, rotating residential as low as $0.63/GB, mobile as low as $0.79/GB, ISP subnets from $1.19/IP.

• Great 24/7 support to help you size your first order.

Testing checklist before you buy the full amount

1. Measure your page weight with the curl command above on 5–10 real target pages, and use the average.

2. Find the safe rate: start at one request every 10 seconds per IP, then speed up until you see 429s or CAPTCHAs, and back off 25%.

3. Check IP quality with the proxy checker and IP lookup before you rely on any IP.

4. Watch your errors: if 407, 403 or 429 codes appear, our guide on how to fix proxy errors tells you whether it's a sizing problem or a setup problem.

5. Wire up your tool: setup guides for Python requests, Scrapy, Playwright and more are on the integrations page.

6. Start sampling with the $4.99 trial: 5 ISP IPs for 1 hour, or 100 MB. That is enough to measure page weight and get a first read on the safe rate for your actual targets; confirm sustained rates and location coverage during your first production week.

Pricing

Know your number? See every tier on the pricing page, start with static ISP proxies, or check any IP with the free proxy checker.

Frequently Asked Questions

Team CleanProxies

Proxy Infrastructure Team

Share