Apify does not sell you a subscription. It sells you a prepaid usage budget with a subscription-shaped price tag on it, and that single fact explains almost every unpleasant surprise people report on their first invoice. Your $29 Starter plan is not "Apify for $29 a month" — it is $29 of credit that compute, proxies, storage and third-party Actor fees all draw down, and when it runs out the meter keeps running.
This guide breaks down what each plan actually includes, what a compute unit is and how to calculate one, every cost that is not in the plan price, the API and scraper limits you will hit, and three worked examples of what real jobs cost.
Disclosure: this page contains affiliate links. If you sign up through one we may earn a commission at no extra cost to you. Every figure below is cited from public sources and Apify's own documentation, and prices change — check the live pricing page before committing budget.
Apify pricing plans at a glance
| Plan | Price / month | Included credit | Compute unit rate | Max concurrent runs |
|---|---|---|---|---|
| Free | $0 | $5 | $0.20 / CU | 25 |
| Starter | $29 | $29 | $0.20 / CU | 32 |
| Scale | $199 | $199 | $0.16 / CU | 128 |
| Business | $999 | $999 | $0.13 / CU | 256 |
| Enterprise | Custom | Custom | Custom | Custom |
Notice what you are buying as you move up: the plan fee and the included credit are the same number on every tier. You are not paying for more product. You are pre-buying usage at a discount — the compute unit rate falls from $0.20 to $0.16 to $0.13 — plus higher resource ceilings and better support.
That has a clean implication. Upgrading only saves money if you were going to spend the money anyway. Moving to Scale to get the $0.16 rate is worth it once your monthly usage is genuinely near $199; below that you are pre-paying for credit you will forfeit, because unused credits expire at the end of each billing cycle and do not roll over.
Annual billing takes roughly 10% off. There is also a lesser-known Creator plan at $1/month plus usage, aimed at people publishing Actors to the Store, which carries a one-time $500 bonus usable within six months but caps residential proxy at 10 GB and SERP queries at 10,000 per month.
What a compute unit actually is
The compute unit (CU) is Apify's core billing metric, and it is refreshingly simple:
1 CU = 1 GB of RAM running for 1 hour.
The formula is just multiplication:
CUs = memory allocated (GB) x runtime (hours)So a job allocated 4 GB that runs for 30 minutes consumes 4 x 0.5 = 2 CU. On the Starter plan at $0.20/CU, that run costs $0.40.
The critical and frequently missed detail: you are billed on memory allocated, not memory used. An Actor set to 8 GB that only ever touches 1 GB still bills at 8 GB. Right-sizing memory allocation is the single highest-leverage cost optimisation on the platform, and it costs nothing but attention.
The costs that are not in the plan price
This is where forecasts go wrong. Compute is only one of four meters, and for scraping workloads it is frequently not the largest.
Proxies
Residential proxy bandwidth is the line item that most often dwarfs compute:
| Proxy type | Free / Starter | Scale | Business |
|---|---|---|---|
| Residential | $8 / GB | $7.50 / GB | $7 / GB |
| SERP | $2.50 / 1k queries | $2 / 1k | $1.70 / 1k |
| Datacenter | from $1 / IP | $0.80 / IP | $0.60 / IP |
At $8/GB, residential proxy traffic is expensive enough that it should drive your architecture. If a target site does not require residential IPs, using them anyway can multiply your bill several times over for no benefit. Test whether datacenter proxies work on your target before defaulting to residential.
Data transfer
External data transfer runs $0.20/GB on the lower tiers, falling to about $0.18/GB higher up. Internal transfer is much cheaper at roughly $0.05/GB dropping to $0.04/GB. A scraping job that pulls 1 GB of page data costs about $0.20 in transfer on Free or Starter — small per job, meaningful across millions of pages.
Storage
Dataset storage bills at about $1.00 per 1,000 GB-hours. Request queues bill at roughly $4 per 1,000 GB-hours — four times the dataset rate, which is worth knowing if you run large crawls with big queues. Writing 10,000 results to a dataset costs on the order of $0.05 on the Free plan.
Retention differs by storage type. Named storages are kept indefinitely. Default unnamed storages follow run retention — on the Free plan, your 10 most recent runs are kept for four months. If you need data to persist, name the storage.
Actor fees
This is the one that catches people hardest, and it deserves its own section.
Actor pricing models: the four you need to recognise
Apify's Store has 30,000+ Actors, and they are not all billed the same way. Before you run anything from the Store, check which model it uses:
- Pay per usage. You are charged only for the compute units consumed. This is the "pure platform" model, and the one the CU maths above describes.
- Pay per result. A fixed price per output record, independent of how long the run takes. Predictable, and often much better value than pay-per-usage for well-optimised scrapers — but a job that returns a million rows costs a million rows.
- Pay per event. A price per discrete action, such as a search performed or a file downloaded.
- Rental. A flat monthly fee for unlimited access to that Actor, charged against your plan credit whether you run it or not.
All of these draw down the same prepaid credit as compute and proxies. Higher plans unlock Store discounts — Bronze on Starter, Silver on Scale, Gold on Business — which reduce third-party Actor fees on participating Actors. If your workload leans heavily on paid Store Actors rather than your own code, those discount tiers can matter more than the compute rate.
Apify API costs and rate limits
The API itself is not separately metered — you pay for what the underlying runs consume. What the API does impose is rate limits, and they are per resource rather than global:
| Operation | Limit |
|---|---|
| Default (per resource) | 60 requests / second |
| Key-value store record CRUD | 200 requests / second per resource |
| Request queue CRUD | 400 requests / second per queue |
| Dataset push | 400 requests / second per storage object |
| Standby Actor requests | 2,000 requests / second per account |
| Global account ceiling | ~250,000 requests / minute |
"Per resource" means per single Actor, per single run, per single dataset, per single key-value store. Exceeding a limit returns HTTP 429 Too Many Requests. Apify's guidance is standard exponential backoff: wait, retry, and double the wait on repeat failures. Most official client libraries implement this for you — if you are calling the REST API directly, implement it yourself before you go to production.
Scraper limits by plan
Resource ceilings are the other thing that changes as you move up a tier, and they are hard limits rather than soft ones.
| Limit | Free | Starter | Scale | Business |
|---|---|---|---|---|
| Max memory per run | 16 GB | 16 GB | 32 GB | 32 GB |
| Combined memory, all runs | 16 GB | 64 GB | 256 GB | 512 GB |
| Max concurrent runs | 25 | 32 | 128 | 256 |
Combined memory is usually the ceiling you hit first in production. On Starter, 64 GB total means 32 concurrent runs at 2 GB each — and if your Actor needs 4 GB, your real concurrency is 16, not the 32 the plan advertises. Work out your concurrency from memory, not from the concurrent-run number.
If you are close to a ceiling, note that you can buy headroom without a full tier jump: extra concurrent runs are $5 per run per month and extra RAM is $1 per GB per month on Starter and above. Compare that against the price of the next tier before upgrading — sometimes the add-on is dramatically cheaper, sometimes the tier upgrade also buys you a better CU rate that pays for itself.
What Apify actually costs: three worked examples
1. A small recurring scrape
One Actor at 2 GB, running 20 minutes, twice a day. That is 2 GB x 0.33 h = 0.66 CU per run, about 40 CU a month. At the Starter rate of $0.20/CU that is roughly $8 in compute. Add modest transfer and storage and you are comfortably inside the $29 Starter credit — with room for a paid Store Actor.
Verdict: Starter, and you will not use all of it.
2. A mid-size daily crawl
Four Actors at 4 GB, each running an hour daily. That is 16 CU a day, roughly 480 CU a month, which is about $96 at Starter rates or $77 at Scale rates. Add 20 GB of residential proxy at $8/GB and you have added $160 — proxy now costs more than compute. Total lands near $250.
Verdict: Scale, because you are past the $199 credit and the lower CU rate and cheaper proxy start paying for themselves.
3. Large-scale price monitoring
A published worked example for monitoring 5,000 SKUs daily puts compute near $480/month and residential proxy at about $315/month — roughly $795 before any Actor rental fees.
Verdict: Business territory. At that volume the $0.13 CU rate and $7/GB proxy rate are saving you real money against Scale, and the Gold Store discount applies to any paid Actors in the pipeline.
Notice the pattern across all three: past a fairly modest scale, proxy bandwidth rivals or exceeds compute. Any cost model that only projects compute units will understate your bill, often by half.
Seven ways to cut your Apify bill
- Right-size memory. You pay for allocated RAM, not used RAM. Profile one run, then set allocation to what it actually needs plus headroom. This alone routinely cuts compute costs by a third or more.
- Avoid residential proxies unless the target demands them. At $8/GB they are the most expensive meter on the platform. Test datacenter first.
- Block images, fonts and media in browser-based scrapers. They consume transfer and slow runs, which costs you twice — once in bandwidth, once in runtime.
- Prefer HTTP scraping over a headless browser where the site allows it. A browser run can be an order of magnitude more expensive in both RAM and time.
- Watch request queue storage. At roughly 4x the dataset rate, an oversized queue is a quiet cost centre on large crawls.
- Compare pay-per-result against pay-per-usage. For a well-optimised Actor, per-result pricing is often cheaper and always more predictable.
- Do not upgrade for the rate alone. Credits do not roll over. Upgrading before your usage genuinely approaches the next tier's credit means paying for headroom you then forfeit at the end of the month.
How Apify pricing compares
Cross-platform comparison is genuinely hard here, because the industry does not share a billing unit — Apify sells compute time, Bright Data sells records, ScrapingBee sells API credits. Broad 2026 entry points look like this:
- Apify — free tier with $5 credit, paid from $29/month, top published tier $999 before Enterprise.
- Bright Data — free tier around 5,000 records/month, pay-as-you-go from roughly $1.50 per 1,000 records, plans from about $499/month.
- Octoparse — paid plans from roughly $99/month, with cheaper annual Standard pricing around $69/month.
- ScrapingBee — from about $49/month with 1,000 free trial credits. Note that Oxylabs acquired ScrapingBee in June 2025.
Apify's genuine advantage on price is the bottom of the range: the free tier is usable for real evaluation, and $29 is the cheapest serious entry point of the four. Its disadvantage is predictability — a per-record price is trivially easy to forecast, and a compute-plus-proxy-plus-storage model is not.
If you want to work out where you land, the free tier is the honest way to do it: run your actual target for a week and read the usage breakdown. You can start on Apify's free tier here and see real numbers on your own workload before committing to any plan.
Which plan should you choose?
- Free — evaluation and genuinely small jobs. $5 of credit, 25 concurrent runs and a 16 GB ceiling is more than most people expect from a free tier, and there is no time limit on it.
- Starter ($29) — solo developers, one or two recurring scrapes, light Store Actor use. The right default for anyone whose monthly usage is realistically under $29.
- Scale ($199) — small teams running production pipelines. Take it when your usage genuinely approaches $199, not before; the 20% lower CU rate and cheaper proxy only pay off at volume.
- Business ($999) — sustained high-volume extraction where the $0.13 CU rate, $7/GB residential proxy and Gold Store discounts are compounding against real spend, and a dedicated account manager has something to manage.
For the wider picture on whether the platform is right for you at all — the Actor library, the SDKs, the reliability record and where it frustrates people — see our full Apify review.
A note on these figures
Apify pricing has changed more than once in the past two years, and third-party summaries frequently lag the live pricing page. Everything above reflects publicly reported figures as of early September 2026, drawn from Apify's own documentation where available. Treat the worked examples as models of the method rather than quotes, and confirm current rates before you build a budget on them.