Scrapfly vs Spider in 2026: credit multipliers and cost

Scrapfly is for teams that want a mature, closed-source scraping API with a broad toolkit: anti-scraping protection that escalates on its own, a screenshot API, a server-side extraction API with templates and LLM prompts, a crawler, a cloud browser and an MCP server, all drawing from one credit pool. It has a 4.9 out of 5 rating across 238 Capterra reviews, and the one independent benchmark we found puts it first of nine. Spider is a research lab for web data quality. Our product is a Rust crawler behind an API, and what we measure ourselves on is whether the page you get back is complete and correct, on every site, at any volume. Speed and cost are the evidence for that claim.

The verdict. If your targets are mostly cooperative and you like a fixed monthly quota, Scrapfly’s Discovery and Pro plans are cheap per page and the platform is well regarded. The moment your workload needs residential proxies and rendering, one request can cost 30 credits instead of one, and a plan that says a million credits is really about 33,000 pages. Spider has no multipliers. You pay for bytes and CPU minutes, a failed request costs nothing, and the bill for a protected page is the same shape as the bill for an easy one. The benchmark figures below are our own and not independently verified, and we say the same about everyone else’s. The compare page covers the rest of the field.

Side by side

Scrapfly pricing in 2026

Here are the plans as of September 2026, from the Scrapfly pricing page. Annual billing gives two months free, which Scrapfly describes as 16% off; the annual totals are not printed on the page.

Free and Discovery stop when the quota is spent. Pro and above switch to pay as you go in 10,000 credit batches at the plan’s rate. No card is needed for the free tier.

How the credits multiply

Every request starts at one credit for a datacenter proxy, and features add to it, per the Scrape API billing docs.

A rendered residential request is 25 plus 5, about 30 credits before bandwidth. ASP is the interesting one: it costs nothing on a page that does not block you, and on a page that does it escalates proxy tier and browser on your behalf, which is where the bill becomes hard to predict. Scrapfly offers a cost_budget parameter to cap what a single request may spend. Failed requests with a status of 400 or above are not billed unless more than 30% of your traffic fails.

What that means at three volumes

Assume one credit per page on cooperative sites, and about 30 on protected ones.

The datacenter column is the case Scrapfly is priced for, and at a million easy pages for $100 it is cheaper per page than most of the market. The right-hand columns are the case most production scrapers live in, and there the plan you thought you bought shrinks by a factor of 30. Spider’s column is from our pricing guide: $1 per GB plus $0.0001 per CPU minute, with rendering rolled into compute, standard proxy rotation included, and $0 for any request that fails. Residential and ISP pools and AI extraction are priced separately on Spider, so the column is smart mode with the default pool; it does not carry a 25x line item. Credits never expire, and every account gets 10,000 requests per minute by default. A fixed bill is available too through Unlimited, from $40 a month for two units of concurrency, with a smaller flat-rate proxy pool than pay as you go.

A concrete case. A price monitor that checks 50,000 product pages a week, 200,000 a month, on retail sites behind bot protection. On Scrapfly that is residential plus rendering, 200,000 times 30 is 6 million credits, which is Enterprise’s 5.5 million plus 50 overage batches at $1.20, about $560 a month. On Spider it is 200,000 pages in smart mode, about $16 to $30 by the guide’s band, and if the site is heavy enough to need chrome mode on every page the band is still under $35.

Success rates, with a caveat

Scrapfly advertises a 98% success rate on its own comparison page. Scrapeway’s independent run from 14 to 28 August 2026 measured 98% success, a 15.3 second average response and $4.90 per 1,000 requests, ranking Scrapfly first of nine APIs. That is a strong result and we are not going to argue with it. Spider’s measured success rate from our 1,000-URL benchmark was 99.9%, though that’s our own benchmark, not independently verified. Take all vendor-reported success rates with appropriate skepticism, including ours.

The two corpora are different, so the numbers do not stack, and 15.3 seconds average is Scrapeway’s measurement of Scrapfly’s response time on their targets, not a throughput figure. Spider’s benchmark corpus ran at 74 pages a second on average and 182 on static pages, on our hardware. Scrapfly publishes no throughput number, so if speed decides it for you, run both on your own list. On a 100,000 page job the difference between 98% and 99.9% is 1,900 pages, which is either noise or a hole in the dataset depending on what you are building.

Where Scrapfly wins

Server-side extraction without an LLM. The Extraction API takes CSS selectors, XPath, regex and JMESPath, and has an auto model and LLM prompts when the HTML is not stable. One credit per template call is cheap for structured data from sites whose markup does not move.

Explicit sessions. Scrapfly keeps cookies and state across requests to the same site by name, which is simpler than driving a browser when all you need is a login that sticks.

Ecosystem reach. Five SDKs including Rust and a Scrapy integration, an MCP server with nine tools and a hosted MCP Cloud, a screenshot API, a crawler that emits WARC and HAR, and a cloud browser, all on one credit pool. If your team is already on Scrapy, this is the shortest path.

Cheap easy pages. At one credit each, 200,000 datacenter pages for $30 is $0.15 per thousand, and Spider’s smart mode band does not go that low.

Where Spider wins

No multipliers. The price of a page does not depend on which proxy tier a bot-protection service forced you into. You can read the bill off bytes and minutes before you run the job, and failed requests cost nothing.

Whole sites in one call. /crawl follows links, deduplicates, controls depth and renders where needed, and returns every page synchronously or as a JSONL stream. Scrapfly’s Crawler API is async and bills as the sum of the scrape calls underneath it.

Smart rendering. Smart mode fetches over plain HTTP and opens a browser only when the page needs one, so there is no rendering surcharge on the pages that never needed a browser.

A browser you can drive with language. Spider Browser is a live session with extract, act, observe and agent methods on the DOM after clicks and scripts have run, which goes further than injecting a JavaScript snippet. And the crawler is MIT licensed, so the open source path exists if you ever want to leave.

Migration: the same page in both

Fetch one product page with rendering, from a US exit, and print the content.

Spider

from spider import Spider
import os

client = Spider(api_key=os.getenv("SPIDER_API_KEY"))

pages = client.scrape_url(
    "https://spider.cloud/pricing/",
    params={
        "return_format": "markdown",
        "request": "smart",
        "country_code": "us",
    },
)
# Billed on bytes and CPU minutes. Same shape whether the site fought back or not.
print(pages[0]["content"][:500])

Scrapfly

import os, requests

resp = requests.get(
    "https://api.scrapfly.io/scrape",
    params={
        "key": os.getenv("SCRAPFLY_KEY"),
        "url": "https://spider.cloud/pricing/",
        "asp": "true",
        "render_js": "true",
        "country": "us",
    },
)
# 1 credit plus 5 for render_js, plus 25 if ASP escalates to residential.
print(resp.json()["result"]["content"][:500])

The calls look alike. Spider returns markdown from the scrape endpoint; Scrapfly returns HTML inside a JSON wrapper, and the cost of the call is decided by the flags and by what ASP chose to do. For a whole site, swap scrape_url for crawl_url and add a limit; parameters are on the crawl endpoint docs.

When to pick which

Pick Scrapfly when most of your pages are cooperative and a $30 or $100 quota covers them, when you want CSS or XPath extraction on stable markup without an LLM in the loop, when you need named sessions, or when your codebase is Scrapy.

Pick Spider when the budget has to be predictable on protected sites, when the job is a site rather than a page, when credits that never expire matter, or when you want a browser you can drive with instructions. The same multiplier question comes up with the other credit-based APIs; see Spider vs ScrapingBee and Spider vs ZenRows for how their tables compare, or Spider vs Firecrawl for the bundle model.

Scrapfly is a good product and its independent numbers back that up. The question is what your pages cost once the multipliers apply. Take one of your harder URLs, run it through the playground, and compare the output and the cost line to what your Scrapfly log shows for the same page.