How to choose the right plan for your scraping volume

Picking a plan is mostly arithmetic: how many request units you will use in a month, whether you need AI extraction or browser rendering, and how much headroom you want. This guide explains how to choose the right plan for your scraping volume, with worked examples at 300 thousand, 2 million, 12 million and 60 million requests a month, using the prices on the pricing page.

Step 1: count request units, not pages

Every plan bills per 1,000 delivered request units. A plain fetch or a CSS/XPath extraction is 1 unit per page, and so is a Markdown conversion. Some operations cost more:

• A render in a real browser is 5 units, 10 with a screenshot, and 1 if you send "block_resources": true.
• AI extraction adds from 2 units per page on fast, from 4 on smart and from 25 on max, on top of the fetch.
• A local business search (/v1/places) is 1 unit per 10 rows returned.

Blocked and failed requests are not billed, so you do not need to budget for retries. A quick example: 1,000,000 pages a month, of which 100,000 need a full render and 50,000 go through fast AI extraction, is 850,000 (plain pages) + 500,000 (renders at 5) + 150,000 (AI pages at 3) = 1,500,000 units. If those renders can use block_resources, the same month is 1,100,000.

Step 2: the plan ladder

Three rules from the pricing page shape every example below:

• Flat monthly price. You pay the plan price whether you use all of the included requests or not, and the per-1,000 rate is simply the price divided by the allowance.
• Unused requests roll over. Whatever is left when your period renews is added to the next period's allowance, so a quiet month funds a busy one.
• Past the allowance, prepaid credit. Extra requests draw on credit you top up in advance, at $0.20 per 1,000. The balance floors at zero and then requests return 402, so there is never a bill after the fact.

Step 3: compare the plan that fits with the one below it plus credit

Credit at $0.20 per 1,000 is dearer than any plan's included rate, but you only buy what you use. So the smaller plan plus credit is often cheaper than the next plan up, until the overflow gets large. This short script prints the two cheapest options for a given monthly volume:

PLANS = [  # name, monthly price in USD, included requests per month
    ("Starter", 99, 600_000),
    ("Growth", 249, 1_600_000),
    ("Scale", 499, 3_400_000),
    ("Business", 999, 7_200_000),
    ("Business XL", 1_999, 15_000_000),
    ("Business XXL", 3_499, 30_000_000),
    ("Business Ultra", 9_999, 100_000_000),
]
CREDIT_PER_1K = 0.20  # prepaid credit, spent after the included requests

def monthly_cost(units):
    """Each plan's cost for `units` request units a month, cheapest first."""
    rows = []
    for name, price, included in PLANS:
        extra = max(0, units - included)
        rows.append((price + extra / 1000 * CREDIT_PER_1K, name))
    return sorted(rows)

for units in (300_000, 2_000_000, 12_000_000, 60_000_000):
    best = monthly_cost(units)[:2]
    print(f"{units:>11,}: " + "; ".join(f"{n} ${c:,.0f}" for c, n in best))

    300,000: Starter $99; Growth $249
  2,000,000: Growth $329; Starter $379
 12,000,000: Business $1,959; Business XL $1,999
 60,000,000: Business XXL $9,499; Business Ultra $9,999

The arithmetic is only half the decision. Here is how to read each line.

300,000 requests a month

Starter, $99. It includes 600,000, so half the allowance is spare and rolls over into next month. That spare is not waste: it covers a busy month without buying credit. 300,000 a month averages about 0.1 requests per second, far under Starter's 50 req/s.

If the job is CSS extraction, Markdown or raw tunneling, with no AI extraction and no rendering, Pool at $19 is worth a look. It is unmetered: there is no request count at all, only a rate limit of 10 requests per second. It runs on non-priority exits, while Starter and every plan above it get priority exits (premium ISP first).

2,000,000 requests a month

Growth plus credit, about $329. Growth's $249 covers 1.6 million; the other 400,000 cost $80 of credit. Scale, at $499 for 3.4 million, only becomes the cheaper choice once you are past 2.85 million a month, the point where the credit for Growth's overflow reaches $250.

The exception is AI extraction. If any of your pages use a prompt, a schema or an extract_type, you need Scale regardless of volume. Pool is still possible at this size, since 2 million a month averages under one request per second, as long as you need neither AI nor rendering.

12,000,000 requests a month

Business plus credit ($1,959) or Business XL ($1,999). They are $40 apart, and the break-even is 12.2 million. The right answer depends on direction: if volume is growing, take XL, whose 15 million leaves 3 million of headroom that rolls over instead of expiring. If 12 million is a peak and most months are lower, Business with a credit balance for the busy months costs less.

Throughput is not the constraint here. 12 million a month averages under 5 requests per second, and both plans allow 1,000.

60,000,000 requests a month

Business XXL plus credit ($9,499) or Business Ultra ($9,999). XXL includes 30 million; the other 30 million cost $6,000 of credit. Ultra includes 100 million, so at 60 million it carries 40 million of headroom forward each month, and it is the cheaper option from 62.5 million up. Keeping a $6,000 credit balance topped up every month is also more to manage than one subscription. At this size, talk to us if you expect to go past 100 million.

Monthly or annual

Every paid plan can be billed annually at ten months' price: two months free. Scale is $4,990 a year instead of $5,988, which brings its effective rate from $0.147 to $0.122 per 1,000. The allowance stays monthly and is topped up every month, so annual changes what you pay, not how much you can use at once. Pay annually once you have run a plan for a month or two and know your volume.

Try your own numbers

The calculator on the home page takes a monthly request count and picks the smallest plan whose allowance covers it. The pricing page has the full cost table for renders and AI extraction. To see what you actually use, start on the Free plan (1,000 requests a month, no card) and check your usage in the dashboard or with GET /v1/account before you commit.

Next steps

Rate limits and per-plan response sizes are in the docs. If rendering drives your volume, scraping JavaScript-heavy pages covers when you can avoid it. Create a free account to measure your own usage first.