Skip to main content

Apify alternative 2026: Spider vs Apify pricing and CUs

What each Apify plan buys in compute units, why proxy bandwidth and Actor memory push the bill higher, what Spider costs per kind of page, and a migration example.

Updated 9 min read

Apify is a marketplace and a hosting platform. You pick a community-built scraper called an actor, or write one with Crawlee, run it on Apify’s servers, and pay for the memory and time it used in compute units, plus proxy bandwidth, plus whatever the actor’s author charges. For a well-known target with a well-maintained actor, that is the fastest route from zero to a dataset that exists.

Spider is a research lab for web data quality, and the product is an API rather than a marketplace. Send a URL to one endpoint, choose http, smart or chrome mode, and get markdown or HTML back with a bill made of bandwidth plus compute. The verdict: if your work is a handful of named platforms with good Store actors, Apify saves you the engineering. If your work is many sites, changing lists, or a crawler feeding an LLM, Spider is the Apify alternative that gives you cleaner pages, a bill you can predict from the page count, and no actor to babysit.

Spider vs Apify side by side

FeatureSpiderApify
Pricing modelUsage: $1/GB plus $0.0001 per CPU minuteMonthly plan with prepaid usage, compute units, proxy GB, actor fees
Entry pricePay as you go from $5 in credits; Unlimited from $40/moFree plan with $5 of usage a month; Starter $19/mo
Cost at 100K pagesFrom $16 on light static pages and $27 to $33 on docs and articles, measured; $40 on Unlimited by our estimate, rendered pages includedDepends on the actor; Starter’s $19 buys 95 CU
LicenseMIT (spider-rs/spider)Platform proprietary; Crawlee Apache-2.0
LanguageRustTypeScript and Python (Crawlee)
Self-hostYes, the engine is open sourceNo; Crawlee runs anywhere, the platform does not
MCP serverYesYes, MIT, hosted at mcp.apify.com
SDKsPython, JavaScript, Rust crateNode and Python stable; Java, Rust, .NET, PHP, Go experimental
Crawl sync/asyncSync with streaming, webhooksrun-sync up to 300 s; async runs with webhooks
Output formatsHTML, raw, text, markdown; JSON, JSONL, CSV, XMLDataset export as JSON, JSONL, CSV, HTML, XLSX, XML, RSS

Apify figures are as of September 2026 from apify.com/pricing and the docs linked below. The Spider figures come from two measured runs of 25 pages a kind, on November 6 and November 17, 2026, written up in the pricing guide, and are not independently verified. The wider table with every vendor we track is on /compare/.

Apify pricing

A compute unit (CU) is 1 GB of memory running for one hour. An actor set to 4 GB that runs for 15 minutes burns 1 CU; the same actor at 1 GB for an hour also burns 1 CU. Every plan gives you a pool of prepaid usage equal to the plan price, and the rate per CU drops as the plan grows:

PlanPer monthAnnual (per month)Prepaid usagePer CUResidential proxyDatacenter IPs
Free$0$0$5$0.20$8/GB5
Starter$19$17$19$0.20$8/GB30, then $1 per IP
Scale$199$179$199$0.16$7.50/GB200, then $0.80 per IP
Business$999$899$999$0.13$7/GB500, then $0.60 per IP
Enterprisecustom

Annual billing takes about 10% off the plan price, so Starter is $17 a month paid yearly, Scale $179 and Business $899, with the same prepaid usage. Datacenter proxies come with the plan, 5 IPs on Free up to 500 on Business, and extra IPs cost $0.60 to $1 each per month. Free needs no card. Unused prepaid usage does not roll over; usage above the pool bills on the next invoice on paid plans and is blocked until the next cycle on Free. All as of September 2026, from apify.com/pricing.

Apify’s pricing page does not say how many pages a CU covers. That depends on the actor’s memory setting and how long each page takes, so the way to price a job is to run a sample and read the CU count. What the page does state is how much compute each plan buys, for your own actor on datacenter proxies with no residential bandwidth and no paid Store actor:

  • Free: $5 buys 25 CU, and usage stops at the pool.
  • Starter: $19 buys 95 CU, with overage at $0.20 per CU.
  • Scale: $199 buys about 1,240 CU, with overage at $0.16.
  • Business: $999 buys about 7,680 CU, with overage at $0.13.

Two things push a real bill higher. The first is residential proxy bandwidth at $7 to $8 per GB, billed on top of CUs. Assume 2 MB per rendered page and 100,000 pages is 200 GB, which is $1,600 on Starter before any compute. That is an assumption about page weight, not an Apify figure, but it is the line that surprises teams. The second is that a Store actor sets its own memory. If its author chose 4 GB where 1 GB would do, you pay four times the CUs for the same pages and nothing in the run log tells you why.

What Spider costs for the same work

Spider bills $1 per GB of content transferred plus $0.0001 per CPU minute. There is no plan pool, JavaScript rendering rolls into compute, standard proxy rotation is included, and a blocked page usually costs a fraction of a cent. In the runs written up in the pricing guide, 100,000 light static pages cost $16, documentation pages and articles $27 to $33, and store product pages and reference articles $138 to $148. At 10,000 pages, divide by ten. Rendered pages cost a median $1.40 per 1,000 in the run we timed on November 16.

Credits never expire, so there is nothing to lose at the end of a month. If you would rather have one flat number, Unlimited sells requests at once, from $40 a month for 2 in http mode, with standard proxy quality, while pay as you go uses our highest quality proxies. By our estimate, that plan carries 100,000 rendered pages a month, one browser request at a time.

What we could not verify

We do not have a published head-to-head benchmark of an Apify actor against Spider on a shared URL list, so this post makes no success-rate claim about Apify. The best public quality signal is G2, where Apify holds 4.7 out of 5 across 534 reviews. Our own figures carry the same caveat: the Spider cost band above is an estimate from our pricing guide, and the 1,000 URL crawl benchmark we published in February 2026 compares Spider with Firecrawl and Crawl4AI, not with Apify.

Where Apify wins

The Store is the reason to use Apify, and it is a real advantage. Actors exist for most named platforms, and for Google Maps, Instagram, Amazon or LinkedIn the good ones encode months of someone else’s selector work. If a maintained actor exists for your target, filling in its form beats writing anything.

Crawlee is a good open source crawling library. It supports Cheerio, Puppeteer and Playwright, it is Apache-2.0, and it runs on your own machines without the platform. Teams that already write Crawlee code get scheduling, storage and a UI when they push it to Apify.

The platform is more than a scraper. Scheduled runs, dataset storage with seven export formats, webhooks, and an MCP server that exposes Store actors as tools mean an actor can be the whole pipeline rather than a step in one. A run can be called synchronously for up to 300 seconds or started asynchronously and reported by webhook, so short jobs and long ones both fit.

Apify is cheap to start on: the Free plan’s $5 buys 25 CU a month.

Where Spider wins

Quality of the page you get back. An actor returns whatever its author decided to extract, in the shape they chose, and when the site changes it returns nothing until they fix it. Spider returns the page itself as markdown, text or HTML with metadata, from any URL, so a layout change costs you a re-crawl rather than a wait for a maintainer.

A bill you can read from the page count. Bytes plus CPU minutes, at two published rates, with no memory setting chosen by someone else. On Unlimited, 100,000 rendered pages a month fit on the $40 plan, and a million take a plan of 16 at $242, whatever each page weighs. The plan sizes are our estimate, not a measurement. They assume the 10 second median of the rendered pages we timed, a browser request counting as 2, and the plan busy half the month. Metered on pay as you go, rendered pages cost a median $1.40 per 1,000 in that run.

No expiring pool. Apify’s prepaid usage resets monthly. Spider credits stay until you spend them.

One engine for the whole list. The /crawl endpoint follows links from a start URL with a limit, and smart mode renders only pages that need a browser, so you are not paying browser CUs on the static half of a site.

Open source all the way down. The Spider engine is MIT and self-hostable. Crawlee is open, but the platform that bills you is not.

Migration: the same task in both SDKs

Crawl a documentation site to 100 pages and collect the text. On Apify this uses the Website Content Crawler actor through the Python client; on Spider it is one call.

Apify:

from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")

run = client.actor("apify/website-content-crawler").call(
    run_input={
        "startUrls": [{"url": "https://example.com/docs"}],
        "maxCrawlPages": 100,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["url"], len(item.get("text", "")))

Spider:

from spider import Spider

client = Spider(api_key="SPIDER_API_KEY")

pages = client.crawl_url(
    "https://example.com/docs",
    params={"limit": 25, "request": "smart", "return_format": "markdown"},
)

for page in pages:
    print(page["url"], len(page["content"]))

The Apify version blocks until the run finishes, then reads the dataset; the actor’s memory setting and the run time decide the CU charge after the fact. The Spider version returns the pages directly, and the charge is the bytes those pages weighed plus the CPU minutes spent. Every parameter, including request: "browser" for sites that always need a browser, is on the crawl endpoint reference.

When to pick which

Pick Apify when a maintained Store actor already covers your target, when you want scheduled runs and dataset storage in one place, or when your team writes Crawlee and wants somewhere to host it.

Pick Spider when the target list is long or changes, when you need page content rather than a fixed schema, when the bill needs to be predictable from volume alone, or when you want to self-host the same engine. Two related comparisons: Spider vs Firecrawl for the other API-first crawler, and Spider vs ZenRows for the credit-based scrapers. The comparison page lists the other head-to-head comparisons.

Before deciding on a spreadsheet, run one of your real URLs through the playground and through an actor, and compare what each one returned.

Frequently asked questions

What is the best Apify alternative?

It depends on what you use Apify for. If you run Store actors for Google Maps or Instagram, another marketplace is the closest match. If you use Apify as a crawler behind an LLM pipeline, Spider does that job through one API with usage billing and no compute unit math. The comparison page prices the other options.

Is there a free Apify alternative?

Spider's crawler engine is MIT licensed at github.com/spider-rs/spider, so you can run it yourself at no license cost. Apify's own Free plan includes $5 of usage a month with no card, and Spider gives you 2,500 free credits, worth $0.25, if your signup passes our checks.

Is Apify good for beginners?

For a known site with a maintained Store actor, yes: you fill in a form and download a dataset. Writing your own actor means learning Crawlee and the compute unit model, which is where most billing surprises come from.

Is Apify open source?

Crawlee, the crawling library Apify maintains, is Apache-2.0 in TypeScript and Python. The Apify platform that runs actors, stores datasets and bills compute units is closed and cannot be self-hosted.

How much does Apify cost per month?

Free is $0 with $5 of usage, Starter is $19, Scale is $199 and Business is $999, each with the same amount of prepaid usage, as of September 2026. Compute costs $0.20 per unit on Free and Starter, $0.16 on Scale and $0.13 on Business, and residential proxy bandwidth is $7 to $8 per GB on top.

Sources

  1. Apify pricing
  2. Apify usage and resources docs
  3. Apify API v2 docs
  4. Apify dataset formats
  5. Crawlee on GitHub
  6. Apify MCP server
  7. Apify on G2
  8. spider-rs/spider on GitHub

Keep reading

Run a page you already scrape

Paste a URL into the playground and read the markdown Spider gives back for it. Keyless runs work without an account and are rate limited.