Crawlera alternative 2026: Spider Cloud vs Zyte API pricing

Zyte is the company behind Scrapy, the Python crawling framework most scraping engineers have used at least once, and Zyte API is where the old Crawlera proxy manager ended up. If you already run Scrapy spiders and want a managed fetch layer that handles blocks and rendering without changing your spider code, Zyte API is the obvious upgrade, and its Scrapy add-on is one line of settings.

Spider Cloud is a research lab for web data quality. The product is an API instead of a framework: one endpoint, http, smart or chrome mode as a parameter, markdown or HTML with metadata back, and a bill made of bandwidth plus compute rather than a per-request rate that depends on which tier Zyte assigned your target this quarter. The verdict: keep Zyte if Scrapy is your codebase and your sites sit in the low tiers. Choose Spider if you are starting fresh, if you want page content rather than HTML to parse, or if you want a price you can compute before the crawl runs.

Side by side

Zyte prices are as of September 2026 from zyte.com/pricing and the API pricing docs. The Spider band is our own estimate from the pricing guide, not independently verified. All the vendors we track sit on one table at /compare/.

Zyte API pricing

Zyte bills per 1,000 successful responses. The rate has two inputs. The first is the website tier, one through five, which Zyte assigns to each site automatically, reviews quarterly, and changes with two weeks of notice. The second is your monthly commitment, which buys a volume discount:

The commitment is charged at the start of the month and is not refunded if you use less. Usage above it bills at the same discounted rate, and nothing rolls over. New accounts get $5 of credit in the first month, $200 on Enterprise, and a 30-day trial.

The per-1,000 rates by tier, for the commitment levels the pricing page prints:

Add-ons: screenshots $0.002 per request; automatic extraction $0.0004 to $0.0016 per data type per request; custom attribute extraction $0.001 per request, or generation at $0.002 per 1,000 input tokens plus $0.01 per 1,000 output tokens. Residential IPs and extended geolocation cost more. Scrapy Cloud, the hosting side, gives a free half unit with a one-hour job limit and charges $9 per unit per month. All as of September 2026, from zyte.com/pricing and the API pricing docs.

The headline “from $0.06 per 1,000” is the tier 1 HTTP rate at the $500 commitment. A tier 3 site rendered in a browser on pay as you go costs $4.02 per 1,000, 67 times that number. You do not choose the tier, and a site can move up a tier after its quarterly review, so the same spider against the same site can cost more next quarter with no change on your side. Zyte publishes a cost estimator to look up a site before you commit.

Three worked volumes, one request per page, all successful, no add-ons:

• 10,000 pages: tier 1 HTTP $1.30, inside the first month’s $5 credit. Tier 3 HTTP $4.40. Tier 1 browser $10.10. Tier 3 browser $40.20.
• 100,000 pages: tier 1 HTTP $13 on pay as you go. Tier 3 HTTP $44. Tier 1 browser $100 at the $100 commitment. Tier 3 browser $240 at the $200 commitment.
• 1,000,000 pages: tier 1 HTTP $100 at the $100 commitment. Tier 3 HTTP $260. Tier 1 browser $480 at the $500 commitment. Tier 3 browser $1,920.

What Spider costs for the same work

Spider bills $1 per GB of content transferred plus $0.001 per CPU minute. There is no tier table, 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 shows the arithmetic per endpoint.

The number worth noticing is that the Spider band does not move when a site gets harder. Bytes are bytes and CPU minutes are CPU minutes; a page that needs a browser costs more compute on that page and nothing more on the rest of the crawl. Credits never expire and there is no commitment. Unlimited, from $40 a month, sells concurrency as a flat fee for teams that want one number, with a smaller flat-rate proxy pool than pay as you go.

What we could not verify

There is no published benchmark that runs Zyte API and Spider against the same URL list, so this post makes no success-rate claim for Zyte. We could not verify an async endpoint, a markdown output option, or a rate limit figure for Zyte API; an earlier version of this post stated a requests-per-minute limit and a Crawlera retirement year we can no longer source, so both are gone. Tier assignment is opaque by design, so the worked volumes above assume a tier; your site may land elsewhere.

Our own numbers carry the same caveat: the Spider band is an estimate from our pricing guide. Our 1,000 URL crawl benchmark from February 2026 covers Firecrawl and Crawl4AI, not Zyte.

Where Zyte wins

Scrapy. Zyte maintains the framework, and scrapy-zyte-api makes Zyte API the download handler for an existing project with a settings change. If you have production spiders, middleware and item pipelines already, nothing else on the market plugs in with less rewriting. That is a real advantage, and it is the reason most Zyte customers are Zyte customers.

Structured extraction as a line item. Automatic extraction of products, articles and similar types at $0.0004 to $0.0016 per data type per request is cheap and returns a schema rather than a page, which suits teams that only want the fields.

Tier 1 HTTP pricing. $0.06 to $0.13 per 1,000 on easy sites is among the lowest per-request prices published anywhere, and at that rate a million static pages is $100.

Scrapy Cloud. Hosting, scheduling and job history for spiders at $9 per unit per month, with a free half unit to start, in the same account as the API.

Where Spider wins

The page you get back. Zyte API returns the HTTP body or browser HTML for you to parse, or a structured record for the types it extracts. Spider returns markdown, text or HTML with metadata from any URL, so the output goes straight into an index or a prompt with no selectors.

A price you can compute before the crawl. Two published rates, no site tiers, no quarterly reassignment. At 100,000 rendered pages the estimate is $8 to $15 against $100 to $240 on Zyte depending on tier, and at a million rendered pages about $80 to $160 against $480 to $1,920. All Spider figures are our own estimates, not independently verified.

No commitment or expiry. Zyte’s discounts require a monthly commitment that is charged whether or not you use it. Spider credits sit until you spend them.

A crawler in the API. The /crawl endpoint follows links from a start URL to a limit, so the spider you would write in Scrapy is one request. Smart mode renders only the pages that need it, so a mostly static site does not pay browser rates throughout.

Open source engine. The Spider engine is MIT and self-hostable. Scrapy is open too; Zyte API, the part that handles blocks and rendering, is not.

Default throughput of 10,000 requests per minute on every account, and Unlimited when you want to buy concurrency outright.

Migration: the same task in both SDKs

Crawl a product catalog to 100 pages and print each page’s size. The Zyte version is a Scrapy spider using the scrapy-zyte-api add-on with browser rendering; the Spider version is one call.

Scrapy with Zyte API:

# settings.py
ADDONS = {"scrapy_zyte_api.Addon": 500}
ZYTE_API_KEY = "ZYTE_API_KEY"
ZYTE_API_BROWSER_HTML = True

# products_spider.py
import scrapy


class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example.com/products"]

    def parse(self, response):
        yield {"url": response.url, "size": len(response.text)}
        next_page = response.css("a.next::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

For a single page without Scrapy, python-zyte-api does the same fetch:

from zyte_api import ZyteAPI

client = ZyteAPI(api_key="ZYTE_API_KEY")
result = client.get({"url": "https://example.com/products", "browserHtml": True})
print(len(result["browserHtml"]))

Spider:

from spider import Spider

client = Spider(api_key="SPIDER_API_KEY")

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

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

The Scrapy version needs a project, a deployment target and the pagination selector. The Spider version follows the links itself and returns markdown with metadata. The crawl endpoint reference lists the parameters, including request: "chrome" for sites that always need a browser.

When to pick which

Pick Zyte when Scrapy is already your codebase, when your targets are tier 1 or 2 HTTP sites, when you want typed extraction of products or articles as a line item, or when hosting spiders on Scrapy Cloud beside the API is convenient.

Pick Spider when you are starting without a Scrapy investment, when you want page content rather than HTML to parse, when the bill has to be predictable across sites you have not tiered yet, or when you want to self-host the engine. Two related posts cover the other proxy-first vendors: Spider vs Oxylabs and Spider vs Bright Data.

The honest way to settle it is one URL from your real list, run through the playground and through Zyte’s cost estimator and trial, comparing the returned content before comparing the bills.