Apify Pricing: Plans, Compute Units, and Real Costs

TL;DR

Apify's plan price is a prepaid budget, not a flat fee. Your real cost comes from compute units, proxies, storage, and per-actor rental fees that stack on top.

• Plans are prepaid usage: the monthly fee is platform credit you then burn down
• Compute units are the core meter: a CU is roughly 1 GB-hour of actor runtime
• Proxies and storage bill separately: residential proxy traffic is a common surprise line
• Store Actors can charge their own rental fees: per-result or monthly, on top of platform usage
• Approximate 2026 pricing: Free with a small monthly credit, Starter around $49, Scale around $499, Business around $999 (verify on apify.com)

Apify is a full scraping and automation platform built around "Actors," which are containerized programs that run on Apify's cloud. If you are evaluating apify pricing, the thing to understand first is that you are not buying a flat subscription. You are buying a pool of platform usage, and several different meters draw it down.

This breakdown explains the plans, the compute model, the costs that do not show up on the headline price, and how the whole thing compares to a flat credit-per-call API like ScrapeGraphAI. Numbers are approximate and current as of 2026, so check Apify's pricing page for exact figures before committing.

Apify Pricing Plans in 2026

Apify's tiers are best read as prepaid platform budgets with rising limits and rates.

The monthly price is mostly platform credit. As you move up tiers, the effective rate per compute unit usually improves and concurrency limits rise. That structure rewards predictable, steady usage and makes light or spiky usage relatively expensive per unit.

To know what you will actually pay, you have to look at the meters that consume the budget.

How Apify Pricing Really Works

Several separate meters draw down your platform usage. The big ones are compute units, proxies, and storage, with per-actor fees layered on top.

Compute units (CU). A compute unit is roughly 1 GB-hour of Actor runtime, meaning an Actor using 1 GB of memory for one hour burns about 1 CU. The per-CU rate varies by plan, often around $0.4 on lower tiers and less on higher ones. An inefficient Actor that uses a lot of memory or runs slowly burns CUs fast.

Proxies. Many real scraping jobs need proxies to avoid blocks. Datacenter proxies are cheaper, but residential proxy traffic is commonly billed around $8 per GB and adds up quickly on image-heavy or large pages. This is the line that most often surprises people.

Storage and data transfer. Datasets, key-value stores, and request queues consume storage, and moving data out has transfer costs. For large crawls these are small but not zero.

Per-actor rental fees. This is the part unique to Apify's marketplace. Many Store Actors are built by third parties and charge their own fee, either per result (for example a price per 1,000 results) or a flat monthly rental, on top of the platform usage the Actor consumes. Two Actors that look similar can cost very differently.

Why Costs Are Hard to Predict

Put those meters together and you see the challenge. A single scraping job's cost depends on how much memory the Actor uses, how long it runs, how much proxy traffic it pulls, how much data it stores, and whether the Actor itself charges a rental fee. None of that is visible from the plan price.

The same 10,000-page job can cost very different amounts depending on the Actor you pick and the proxy type it uses. That flexibility is powerful, but it makes forecasting harder than a model where each unit of work has a fixed price.

How Much Does Apify Cost Per Result?

There is no single answer, because cost depends on the Actor and the proxy mix. A rough way to think about it:

The takeaway: Apify can be cheap when you run efficient Actors on datacenter proxies, and expensive when residential proxy traffic and per-result rental fees stack up. Your cost per result is something you have to measure for your specific setup, not read off a page.

Hidden Costs and Gotchas

1. Residential proxy traffic

The most common budget surprise. Residential proxies are billed by bandwidth, so large or media-heavy pages drain credit faster than expected. Use datacenter proxies where the target allows it.

2. Inefficient Actors burn compute

Because CUs are memory-time, an Actor that requests a lot of memory or runs slowly costs more for the same output. A poorly tuned Actor can quietly double your compute spend.

3. Per-actor rental fees stack

A Store Actor's rental fee is separate from the platform usage it consumes. You can pay the Actor author and pay Apify for the run. Read both before you rely on a marketplace Actor.

4. Credit does not roll over

Prepaid platform usage is monthly. Unused budget generally does not bank to the next cycle, so paying for a higher tier you do not fully use is wasted spend.

5. Concurrency limits by tier

Lower tiers cap how many Actor runs happen at once. Large batch jobs queue, which pushes time-sensitive teams to upgrade for throughput rather than features.

Apify vs ScrapeGraphAI: Head-to-Head

Apify and ScrapeGraphAI solve overlapping problems with very different pricing philosophies. Apify is a broad platform with usage-based, multi-meter billing. ScrapeGraphAI is an AI extraction API with one flat meter: credits per call.

ScrapeGraphAI's credit model is the contrast that matters. Markdown or HTML extraction is 1 credit per call. AI structured extraction (JSON) is 5 credits. A screenshot is 2. The cost of a call does not change with page size, runtime, or proxy traffic, so you can forecast spend directly from call volume.

Cost at Scale

A rough monthly comparison for an AI structured-extraction workload, where each extraction is one ScrapeGraphAI call at 5 credits. Apify figures are indicative only, since they depend heavily on Actor efficiency and proxy type.

The Apify range is wide on purpose, because that is the honest picture: an efficient datacenter-proxy Actor lands near the low end, while residential proxies and per-result fees push toward the high end. ScrapeGraphAI's numbers are fixed by call volume. To model your own scrape, extract, search, and crawl mix, use the ScrapeGraphAI price calculator.

From Platform to API: What You Trade

Apify's strength is breadth. There are Actors for many sites, a scheduler, storage, and an ecosystem. The cost is complexity: several meters, marketplace fees, and per-job cost that you have to measure.

If your need is narrower, an AI extraction call is simpler to reason about and to bill:

from scrapegraph_py import ScrapeGraphAI
 
sgai = ScrapeGraphAI(api_key="sgai-...")
 
response = sgai.extract(
    "Extract the product name, price, and currency",
    url="https://example.com/products",
)
 
data = response.data.json_data

One call, a known credit cost, structured JSON back. No compute units to tune, no proxy bandwidth meter to watch, no second bill from an Actor author. When you need a strict shape, pass a Pydantic model or JSON schema.

When to Choose What

Choose Apify if: you want a broad automation platform, you can use or build efficient Actors, you need the marketplace of pre-built scrapers, or you have the engineering time to tune compute and proxy usage.

Choose ScrapeGraphAI if: you want predictable per-call pricing, your core need is AI extraction from known URLs, you are wiring extraction into a pipeline, or your volume is spiky and you do not want to reserve platform budget you might not use.

Some teams run both: Apify for broad crawling and orchestration, ScrapeGraphAI for the extraction step where flat credit pricing keeps costs predictable.

FAQ

How much does Apify cost?

As of 2026, Apify offers a Free plan with a small monthly platform credit (around $5), a Starter plan around $49 per month, a Scale plan around $499 per month, and a Business plan around $999 per month, with custom Enterprise pricing above that. The monthly fee is prepaid platform usage, and your real cost depends on compute units, proxies, storage, and any per-actor fees. Confirm current numbers on apify.com.

What is a compute unit in Apify?

A compute unit (CU) is roughly 1 GB-hour of Actor runtime. An Actor using 1 GB of memory for one hour consumes about 1 CU. The per-CU rate varies by plan. Because it is memory multiplied by time, an inefficient Actor costs more for the same output.

Why is Apify pricing hard to predict?

Apify bills several meters at once: compute units, proxy traffic, storage and transfer, and sometimes a per-result or monthly fee charged by a marketplace Actor. The same job can cost very different amounts depending on the Actor's efficiency and the proxy type, so per-result cost is something you measure rather than read off the plan.

Is ScrapeGraphAI cheaper than Apify?

For focused AI extraction, ScrapeGraphAI is usually cheaper and far easier to forecast, because each call costs a fixed number of credits regardless of runtime or proxy traffic. Apify can be cheaper for efficient large crawls on datacenter proxies, but residential proxy traffic and per-actor fees can push its cost above a flat credit model. The right choice depends on your workload and how predictable you need the bill to be.

Related Articles

• Firecrawl Pricing: Plans, Credits, and Costs
• Octoparse Pricing: Plans, Tasks, and Real Costs
• ScrapeGraphAI vs Apify
• Best Apify Alternatives