Quick answer: A Compute Unit (CU) = 1 GB of RAM used for 1 hour. Effective cost is about $0.13–$0.20 per CU depending on your plan. Most small scraping runs total $0.001–$0.05 in CU terms; large browser crawls can reach dollars to tens of dollars if you scale memory, concurrency, and duration.
Apify compute units (CUs)
Compute units translate memory × time into a single number you can budget. They do not by themselves include Actor pay-per-result or pay-per-event surcharges. Those line items appear separately on each Store listing.
Checked live against apify.com/pricing on 2026-09-09. One number moved since our last pass: Starter is $19/month ($17 billed annually), not $29. If you've seen $29 quoted for Starter somewhere, that's an old figure; the $/CU rates below are unchanged.
CU formula (calculator style)
CUs = GB of RAM allocated × runtime in hours
| Scenario | Calculation | CUs |
|---|---|---|
| 1 GB for 1 hour | 1 × 1 | 1.0 |
| 2 GB for 30 minutes | 2 × 0.5 | 1.0 |
| 4 GB for 15 minutes | 4 × 0.25 | 1.0 |
| 512 MB for 30 minutes | 0.5 × 0.5 | 0.25 |
| 8 GB for 5 minutes | 8 × (5/60) | ~0.67 |
Apify meters actual resource use for the run; the table above is the mental model for estimates.
CU cost by plan
| Plan | Typical $/CU | How to think about it |
|---|---|---|
| Free | $0.20 | Included $5/month credits consume at this rate |
| Starter ($19) | $0.20 | Same nominal CU rate; $19/month included usage ($17 billed annually) |
| Scale ($199) | $0.16 | Better CU economics for steady workloads |
| Business ($999) | $0.13 | Best standard-tier CU rate before enterprise quotes |
| Enterprise | Custom | Volume + contract terms |
Paid plans advertise a monthly dollar credit. Your effective $/CU is the rate in this table; the credit is how much prepaid usage you get before pay-as-you-go kicks in (see live pricing for your region).
Quick “what if” cost examples
Assume $0.20/CU (Free/Starter) for illustration:
| Run profile | CU estimate | CU cost (approx.) |
|---|---|---|
| 0.05 CU micro crawl | 0.05 | $0.01 |
| 0.2 CU small browser job | 0.2 | $0.04 |
| 2 CU medium crawl | 2 | $0.40 |
| 20 CU heavy browser day | 20 | $4.00 |
On Scale ($0.16/CU) or Business ($0.13/CU), multiply by roughly 0.8× or 0.65×: steady high-volume workloads earn a lower per-CU rate.
Examples by Actor class
| Class | RAM hint | Duration drivers | CU outlook |
|---|---|---|---|
| HTTP extractors | 0.25–1 GB | Pages, concurrency | Low CUs per 1k pages |
| Headless browsers | 2–4 GB | Render time, assets | Medium–high CUs |
| Heavy Playwright flows | 4+ GB | Login + SPA | High CUs; keep concurrency tight |
Order-of-magnitude benchmarks (rough):
| Job | Items / pages | CU band (indicative) | At ~$0.20/CU |
|---|---|---|---|
| Light HTTP list scrape | 1,000 | 0.1–1 | $0.02–$0.20 |
| Browser e-commerce pass | 1,000 | 2–8 | $0.40–$1.60 |
| Maps-style browser run | 500 | 0.5–3 | $0.10–$0.60 |
Treat these as Fermi estimates. Anti-bot retries, proxies, and fat pages can 2–3× consumption.
Two worked scenarios
Same formula as above (GB × hours), run monthly instead of once:
| Scenario | Run profile | CUs / month | Monthly CU cost |
|---|---|---|---|
| Nightly HTTP list scrape | 0.5 GB, 30 runs × 24 min | 6 CU | ~$1.20 on Starter ($0.20/CU) |
| Daily headless product crawl | 3 GB, 30 runs × 40 min | 60 CU | ~$9.60 on Scale ($0.16/CU) |
Both fit comfortably inside each plan's included usage (Starter's $19, Scale's $199). CU cost is rarely what pushes a real workload past its credits. A Store Actor's own per-result or per-event fee usually gets there first: see the box below.
Some Store Actors bill per item or per event in addition to CUs. Open the Pricing tab on the Actor page before you extrapolate from CU math alone.
Add-ons that sit beside CUs
- Extra concurrent runs: Monthly fee per additional parallel slot.
- Extra RAM: Monthly per GB beyond plan limits.
- Proxies: Apify Proxy usage is billed separately from raw CUs. See rotating proxies if blocked pages are inflating your runtime too.
How to read usage after a run
- Open Apify Console → select the run → Usage / metrics.
- For account totals, use Billing and usage exports.
- Via API, inspect run objects for usage fields in your automation.
Tips to reduce CU usage
- Right-size memory: don’t default to 4 GB if 1 GB passes your smoke test.
- Prefer HTTP parsers when DOM does not require a browser.
- Lower concurrency to cap simultaneous RAM.
- Clamp
maxItems/maxCrawlDepthto avoid exploratory explosions. - Deduplicate URLs in the request queue.
- Set max cost per run in Actor options for guardrails.
- Measure with a 1% sample before you schedule huge nightly jobs.
For an ongoing playbook (request-queue design, memory profiling, scheduling patterns), see Apify cost optimization.
Apify's free credits are designed for validation. Run short jobs, read the CU line item, then multiply. If $19/month for Starter still feels like a jump, the Free plan's $5 credit buys 25 CU at $0.20 each. That's enough to cover every single-run example in the cost tables above, up through the 20 CU heavy browser day.
One CU equals 1 GB of RAM allocated to a run for one full hour. Shorter runs and smaller memory footprints consume fractions of a CU. Apify displays actual usage per run in the Console.
On public 2026 list pricing, the effective rate is about $0.20/CU on Free and Starter plans, $0.16/CU on Scale, and $0.13/CU on Business, before any discounts or promos. Enterprise contracts differ.
Browser mode, retries, proxies, large concurrency, and heavy pages all extend runtime or raise memory. Failed attempts that retry still consume resources. Compare two runs with the same input except one variable at a time.
No. You may also pay for Store **per-result** or **per-event** fees, proxy traffic, extra RAM slots, or add-on concurrency. Review the Actor Pricing tab and your billing breakdown.
Multiply planned GB by hours, then discount if you know the Actor finishes faster than the timeout. The reliable method is a 50–200 item pilot run, then linear extrapolation with a safety factor for bot retries.
Local runs on your laptop do not consume Apify CU until you execute on the Apify platform. Pushing the same code to a cloud Actor uses CU metering there.
Common mistakes and fixes
My CU usage is inconsistent between runs.
Check target-site volatility, browser mode, and retry behavior. Dynamic pages and anti-bot retries increase CUs.
I cannot map CUs to business output.
Track cost per useful record and compare against your lead, monitoring, or data acquisition value.
I do not know if browser scraping is worth it.
Run the same sample with HTTP-first and browser-based approaches, then compare extraction quality vs CU cost.