Zyte vs. Apify vs. Crawlbase: Which Scraping Platform Should You Choose?

Short answer: choose Zyte when your team wants managed scraping with strong Scrapy alignment, Apify when you want an Actor platform and ready-made marketplace tools, and Crawlbase when an API and crawler workflow with shared billing fits your stack. There is no universal winner. Run the same representative sites and workload through each service, then compare cost per successful usable result and the operational work required.

If your requirement is specifically clean website screenshots rather than extracted records, start with ScreenshotNeo. It is a dedicated screenshot API with consent-banner and popup cleanup, billing that counts only clean shots, and an MCP server for AI agents.

What each platform is designed to do

Platform	Product model	Best fit to evaluate	Pricing basis
Zyte	Managed scraping API with HTTP and browser-rendered requests, plus automatic extraction options.	Scrapy-based teams that want managed request handling, browser rendering, and extraction.	Target website and request type determine the tier. Commitments can change the per-request rate.
Apify	Actor platform with managed execution, a marketplace/store, and platform usage.	Teams that can reuse ready-made Actors or need a flexible runtime for custom Actors.	Plan credits plus compute units and other usage such as proxy, storage, and Actor execution.
Crawlbase	Scraping APIs, crawler, proxy, and storage products under a shared balance and rate card.	API-oriented workflows that benefit from one account balance across crawling products.	Graduated successful-request rates, adjusted by site difficulty and JavaScript rendering, with optional subscriptions.

These are hosted software services and APIs. They are not interchangeable hardware products, browser extensions, or generic automation tools.

How to choose: a decision tree

Do you primarily need screenshots? Use a screenshot API such as ScreenshotNeo. Scraping platforms can render pages, but they are designed around responses, records, or crawled content.
Do you already use Scrapy? Put Zyte first in your pilot because its managed request and browser workflow aligns closely with Scrapy projects.
Do you want prebuilt tools? Evaluate Apify’s Actor Store and managed execution against the time your team would spend building and operating those tools.
Do you want one API-oriented account balance across crawling products? Evaluate Crawlbase’s current unified pricing model and rate card.
Do pages depend heavily on JavaScript? Test browser-rendered requests or JavaScript-enabled crawling on your actual target sites. Do not infer performance from a headline price.
Do you need predictable unit economics? Measure successful usable results, including rendering, extraction, proxy, storage, and retry costs where applicable.

Pricing comparison (checked September 29, 2026)

Prices change, and the units are different. Treat the values below as a point-in-time reading of the vendors’ public pages, not a permanent rate card or benchmark.

Provider	Published pricing mechanics	What changes the bill
Zyte	Pay-as-you-go HTTP response-body requests were listed at $0.13–$1.27 per 1,000; browser-rendered requests at $1.01–$16.08 per 1,000 across five displayed tiers.	Target website, request type, commitment level, actions, network captures, screenshots, automatic extraction, and custom attributes. Unsuccessful and rate-limited responses are described as free.
Apify	Displayed plans were Free ($0 with $5 to spend), Starter ($19/month), Scale ($199/month), and Business ($999/month). Displayed compute-unit prices were $0.20, $0.20, $0.16, and $0.13.	Actor runtime, compute units, proxy, storage, concurrency, and the selected Actor’s own resource use.
Crawlbase	The current page describes pay-as-you-go with no monthly fee, a graduated standard-request ladder from $3 per 1,000 in the first bracket down to $0.02 beyond the largest displayed bracket, plus optional subscription blocks beginning at $99/month.	Successful requests, site difficulty, JavaScript rendering, and the product used. Crawling API, Crawler, Smart AI Proxy, and Cloud Storage share the balance.

Zyte’s tier assignment is site- and request-dependent, so its calculator is necessary for a project estimate. Apify’s plan price does not predict the cost of a particular Actor. Crawlbase’s rate-card examples are not a controlled comparison with either vendor. Recheck all prices before purchase.

Workflow and feature differences

Zyte

Zyte is a managed request and rendering service. Its documentation describes request-type and target-site tiers, with browser rendering available when a normal HTTP response is insufficient. The comparative material also highlights its alignment with Scrapy workflows. Extra charges may apply for actions, network captures, screenshots, automatic extraction, and custom attributes. Ask whether your target domains, geography, login flow, and extraction shape fit the tier assigned to each request.

Apify

Apify organizes work as Actors. You can run a ready-made Actor from its store, configure a custom Actor, and use managed execution and platform storage. This model can reduce build time when a suitable Actor already exists, but it adds platform dimensions to your cost model: runtime, compute units, proxy use, storage, concurrency, and the Actor’s implementation. If you publish Actors, Apify’s public opportunity is an Actor Store publisher model in which developers can earn when customers run their tools; that is different from a conventional affiliate program.

Crawlbase

Crawlbase presents crawling APIs, a crawler, proxy, and storage products. Its current pricing page describes one shared balance and rate card across those products. The page also explains that site difficulty and JavaScript rendering affect request cost. Confirm whether your workflow is billed on successful usable responses and how retries, rendering, proxy selection, and storage map to the balance.

A fair pilot you can run

Define the sample. Select representative static pages, JavaScript-heavy pages, blocked or rate-limited pages, paginated pages, and pages from each required geography.
Freeze the workload. Record URL count, request volume, concurrency, browser-rendered share, proxy or region requirements, extraction fields, storage retention, and retry policy.
Use equivalent success criteria. A success is a usable record that passes your validation rules, not merely an HTTP response.
Run each provider separately. Keep credentials, code, and output schemas isolated so one platform’s defaults do not influence another’s result.
Record operations. Track setup time, debugging time, selector or schema maintenance, queue behavior, retries, and support interactions.
Calculate unit economics. Divide total spend and operator time by successful usable records. Report static and JavaScript-heavy workloads separately.
Review failure modes. Check bot checks, consent walls, blank pages, timeouts, malformed output, duplicate records, and partial extraction.

Minimal request templates

The exact endpoint, authentication header, and payload fields depend on the product and operation you select. Copy the request shape from the provider’s current documentation before running these templates; do not compare a browser-rendered request with a plain HTTP request as if they were equivalent.

# cURL template
curl -u 'YOUR_API_KEY:' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com"}' \
  'YOUR_PROVIDER_ENDPOINT'

# Python template
import os
import requests

endpoint = os.environ["PROVIDER_ENDPOINT"]
response = requests.post(
    endpoint,
    auth=(os.environ["PROVIDER_API_KEY"], ""),
    json={"url": "https://example.com"},
    timeout=90,
)
response.raise_for_status()
print(response.text)

// Node.js template
const endpoint = process.env.PROVIDER_ENDPOINT;
const key = process.env.PROVIDER_API_KEY;

const res = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'Authorization': `Basic ${Buffer.from(`${key}:`).toString('base64')}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ url: 'https://example.com' })
});
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
console.log(await res.text());

For a real pilot, replace the endpoint and payload with the operation documented by Zyte, Apify, or Crawlbase, and record the request mode (HTTP, browser, Actor, crawler, proxy, or extraction) beside every measurement.

Common mistakes and troubleshooting

Symptom	Likely cause	Fix
Costs are far above the headline rate	You compared different request types or ignored rendering, proxy, storage, extraction, or Actor runtime.	Break the estimate into request mode, successful results, rendering share, and every add-on.
HTML is empty or missing content	The page renders data in JavaScript or requires a session.	Use the provider’s browser-rendered mode, pass the required cookies or headers, and validate after rendering.
Many responses are blocked	Target-site defenses, rate limits, geography, or an unsuitable concurrency level.	Reduce concurrency, use the documented proxy or region controls, respect site rules, and classify blocked responses separately.
Apify spend is hard to predict	Actor runtime and resource use differ from the plan’s displayed compute-unit rate.	Measure one complete Actor run, including proxy and storage, then project from observed successful records.
Crawlbase estimate differs from an older article	The current pricing page uses a unified balance and rate card; older descriptions may reflect an earlier model.	Use the current official pricing page and confirm the applicable difficulty and JavaScript multipliers.
Zyte tier seems unexpected	Tier assignment depends on target website and request type and can be reviewed periodically.	Check the calculator and request classification. Zyte documents quarterly reviews and two weeks’ notice for affected customers.

Performance, reliability, and cost controls

Separate static and browser-rendered queues so expensive work is intentional.
Cache immutable pages and avoid re-fetching unchanged URLs.
Set bounded timeouts and retries with backoff; record the final reason for every failure.
Use idempotent job keys so retries do not create duplicate records.
Validate required fields before writing to storage.
Cap concurrency per domain and monitor rate-limit responses.
Track cost per successful usable result, not cost per attempted request.
Recheck pricing and product limits before scaling a pilot into production.

Or skip the browser setup

If the output you need is a clean screenshot, use ScreenshotNeo instead of assembling a browser, consent handling, popup removal, and capture pipeline. One GET request returns PNG, JPEG, WebP, or PDF. Before capture it accepts consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and the response reports the verdict and billing status in X-Page-Verdict and X-Billed headers. It also provides an MCP server with take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.

See the ScreenshotNeo documentation for all options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo includes full-page capture, element selectors, dark mode, device presets, retina scale, PDF controls, custom CSS and JavaScript, clicks, waits, blocking rules, headers, cookies, user agents, authorization, timezone, geolocation, transparency, resizing, caching, signed links, async webhooks, bulk capture, usage reporting, and an OpenAPI specification. Every feature is on every plan. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000.

Create a free ScreenshotNeo account and start with 1,000 screenshots a month at no charge.

FAQ

Which service is cheapest?

There is no universal answer because Zyte, Apify, and Crawlbase meter different units. Compare your own successful usable results and include rendering, proxy, storage, extraction, and runtime costs.

Is Apify an API or a scraping marketplace?

It is an Actor platform with managed execution and a store of ready-made tools. You can run existing Actors or build your own.

Does Crawlbase still use separate product pricing?

Its current pricing page describes one shared balance and rate card across Crawling API, Crawler, Smart AI Proxy, and Cloud Storage. Verify the current page before committing.

When should I use a screenshot API instead?

Use one when the deliverable is a visual capture or PDF rather than structured records. ScreenshotNeo is designed for that workflow and includes cleanup and billing signals for failed captures.

How should I keep this comparison current?

Recheck each vendor’s pricing calculator, plan page, limits, and documentation immediately before publication or purchase. The figures in this article were accessed September 29, 2026.