Apify alternative 2026: Spider vs Apify pricing and CUs

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 gives you cleaner pages, a bill you can predict from the page count, and no actor to babysit.

Side by side

Apify figures are as of September 2026 from apify.com/pricing and the docs linked below. The Spider band is our own estimate from the pricing guide, 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:

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 own help article gives the two numbers you need to turn CUs into pages: a Cheerio (plain HTTP) actor averages about 3,000 pages per CU, and a browser actor about 300. So 1,000 pages cost about 0.33 CU with Cheerio, or $0.067 on Starter, and about 3.33 CU with a browser, or $0.67 on Starter and $0.43 on Business.

Three worked volumes, your own actor, datacenter proxies, no residential bandwidth and no paid Store actor:

• 10,000 pages: Cheerio is 3.3 CU or $0.67, inside the Free plan’s $5. A browser actor is 33.3 CU or $6.67, over the Free pool, so Starter at $19.
• 100,000 pages: Cheerio is $6.67 of usage, so Starter’s $19 floor. Browser is $66.67, which is Starter plus $47.67 of overage.
• 1,000,000 pages: Cheerio is $66.67 on Starter. Browser is 3,333 CU; the cheapest fit is Scale at $199 plus overage at $0.16, about $533.

Two things make real bills higher than that table. 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 request that returns an error costs $0. A mixed workload comes to about $8 to $15 per 100,000 pages in smart mode by our own estimate, not independently verified. A 10,000 page month in http mode is about $0.80 to $1.00, and 1,000,000 pages in chrome mode with markdown and metadata is about $80 to $160. The pricing guide breaks it down per endpoint.

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 concurrency from $40 a month, with a smaller flat-rate proxy pool than pay as you go.

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.

At very low volumes with a plain HTTP actor, Apify is cheap: 10,000 Cheerio pages fit in the free $5 of usage.

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. At 100,000 rendered pages the estimate is $8 to $15 against about $67 in compute on Apify before proxy bandwidth, and at a million rendered pages about $80 to $160 against about $533. Those Spider figures are our own estimates, not independently verified.

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": 100, "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: "chrome" 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 best Apify alternatives hub ranks all of them.

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