# Scrapfly vs Spider in 2026: credit multipliers and cost

Scrapfly's 2026 plans and credit multipliers worked through at 10K, 100K and 1M pages against Spider usage billing, plus the independent success-rate numbers.

Canonical: https://spider.cloud/blog/spider-vs-scrapfly/

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 prices the bytes and CPU minutes a page took, rendering included, and a blocked page usually costs a fraction of a cent. By our estimate Spider’s $40 Unlimited plan carries 100,000 rendered pages a month, one browser request at a time, against $100 on Scrapfly Pro. Bandwidth through a premium proxy bills at 1.5x to 4x the base rate. The benchmark figures below are our own and not independently verified, and we say the same about everyone else’s. The [compare page](/compare/) covers the rest of the field.

## Side by side

| Feature            | Spider                                                                                                                                  | Scrapfly                                                                                          |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Pricing model      | Usage: $1/GB plus $0.0001 per CPU minute, rendering billed as compute, credits never expire                                             | Monthly credit quota with per-feature multipliers; Pro and above go pay as you go after the quota |
| Entry price        | 2,500 free credits, worth $0.25, if your signup passes our checks; pay as you go from a $5 top-up; Unlimited concurrency from $40/mo    | Free 1,000 credits on signup; Discovery $30/mo for 200,000 credits                                |
| Cost at 100K pages | From $16 on light static pages and $27 to $33 on docs and articles, measured; $40 on Unlimited by our estimate, rendered pages included | $30 datacenter only; $100 with rendering; $350 residential with rendering                         |
| License            | MIT (spider-rs/spider)                                                                                                                  | Proprietary; SDKs and MCP server open source                                                      |
| Language           | Rust                                                                                                                                    | Closed source                                                                                     |
| Self-host          | Yes, the crawler is the open source crate                                                                                               | No                                                                                                |
| MCP server         | Yes                                                                                                                                     | Yes, open source, plus a hosted MCP Cloud                                                         |
| SDKs               | Python, JavaScript, Rust, Go, CLI                                                                                                       | Python, TypeScript, Go, Rust, Scrapy                                                              |
| Crawl mode         | Synchronous or streamed as JSONL                                                                                                        | Scrape API sync (155 second timeout); Crawler API async with UUID polling or webhook              |
| Output formats     | Markdown, commonmark, text, XML, raw HTML, bytes; JSON, JSONL, CSV or XML responses                                                     | Raw, clean HTML, JSON, markdown, text; crawler adds screenshots, PDF, WARC and HAR                |

## Scrapfly pricing in 2026

Here are the plans as of September 2026, from the [Scrapfly pricing page](https://scrapfly.io/pricing). Annual billing gives two months free, which Scrapfly describes as 16% off; the annual totals are not printed on the page.

| Plan       | Monthly            | Credits per month | Concurrency | Extra credits per 10,000 |
| ---------- | ------------------ | ----------------- | ----------- | ------------------------ |
| Free       | $0                 | 1,000 on signup   | 5           | not available            |
| Discovery  | $30                | 200,000           | 5           | not available            |
| Pro        | $100               | 1,000,000         | 20          | $3.50                    |
| Startup    | $250               | 2,500,000         | 50          | $2.00                    |
| Enterprise | $500               | 5,500,000         | 100         | $1.20                    |
| Custom     | $1,200 to $30,000+ | negotiated        | negotiated  | negotiated               |

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](https://scrapfly.io/docs/scrape-api/billing).

| Feature                            | Credit cost                                                                            |
| ---------------------------------- | -------------------------------------------------------------------------------------- |
| Base request, datacenter proxy     | 1                                                                                      |
| Residential proxy                  | 25                                                                                     |
| JavaScript rendering (`render_js`) | +5                                                                                     |
| Bandwidth                          | First 1 MB free, then 3 credits per 100 KB on datacenter, 10 per 100 KB on residential |
| Anti-scraping protection (ASP)     | Free when the page is not blocked; may upgrade the proxy and browser when it is        |
| Extraction API                     | 1 per template call, 5 per LLM prompt or auto model                                    |
| Screenshot API                     | 60                                                                                     |
| Country selection                  | Free                                                                                   |

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.

| Monthly pages | Scrapfly, datacenter only | Scrapfly, rendered             | Scrapfly, residential and rendered     | Spider                                                        |
| ------------- | ------------------------- | ------------------------------ | -------------------------------------- | ------------------------------------------------------------- |
| 10,000        | $30 (Discovery)           | $30 (Discovery)                | $100 (Pro)                             | From $1.60, or $40 on Unlimited                               |
| 100,000       | $30 (Discovery)           | $100 (Pro)                     | $350 (Startup plus overage)            | From $16, or $40 on Unlimited                                 |
| 1,000,000     | $100 (Pro)                | $560 (Enterprise plus overage) | about $3,440 (Enterprise plus overage) | $40 on Unlimited in http mode, $242 rendered, by our estimate |

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 pay as you go figures start at the lightest pages in our [pricing guide](/guides/pricing-and-plans/), light static pages at $16 per 100,000. Cost varies by site, and documentation and articles measured $27 to $33. The two runs behind those figures covered 25 pages a kind, on November 6 and November 17, 2026. The meter is $1 per GB plus $0.0001 per CPU minute, with rendering rolled into compute, standard proxy rotation included, and a blocked page billed at the 0.01 credit page minimum plus its compute. 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 pay as you go starts at 10,000 requests per minute and rises through four levels to 80,000 as the account uses more.

The Unlimited figures are for [Unlimited](/docs/api/unlimited/), a fixed bill from $40 a month for 2 requests at once in http mode, with standard proxy quality, while pay as you go uses our highest quality proxies. Page weight does not change the Unlimited price. How many pages a plan carries is our estimate, not a measurement. A request counts as 1 in http mode and 2 in browser mode. Smart mode, the default, counts as 1, and as 2 once a page needs a browser. At 2.5 seconds a request, above the 1.5 second median of the plain fetches we [timed on November 16](/blog/how-web-scraping-works/), and with the plan busy half the month, two http requests at once carry about a million pages.

Rendered pages run longer, a median 10 seconds in that same run, and a browser request counts as 2, so the $40 plan runs one at a time. 100,000 of them still fit at half load, against $100 on Scrapfly Pro. A million take a plan of 16 at $242, eight browser requests at once. Metered on pay as you go, they cost a median $1.40 per 1,000 in that run.

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’s Unlimited plan the plan size sets the bill. Rendered pages took a median 10 seconds in the run we timed. A browser request counts as 2, so 200,000 such pages a month need two requests at once at half load, a plan of 4. That is $72.50 a month, by our estimate. Unlimited runs on standard proxies. If a site blocks them, the fallback is pay as you go with a premium proxy, which we have not measured. Store product pages on the default pool measured $1.38 to $1.48 per 1,000, $276 to $296 for the month, before a proxy’s 1.5x to 4x bandwidth rate.

## 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](/blog/firecrawl-vs-crawl4ai-vs-spider-honest-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, just under the $0.16 per thousand that light static pages measured on Spider pay as you go.

## Where Spider wins

No rendering multiplier. A page costs its bytes and CPU minutes, rendering included, and bandwidth through a premium proxy bills at 1.5x to 4x the base rate. You can read the bill off bytes and minutes before you run the job, and a blocked page usually costs a fraction of a cent.

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](/docs/api/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

```python
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

```python
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](/docs/api/scrape/); 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](/docs/api/crawl/).

## 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](/blog/spider-alternative-to-scrapingbee/) and [Spider vs ZenRows](/blog/spider-alternative-to-zenrows/) for how their tables compare, or [Spider vs Firecrawl](/blog/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](/playground/), and compare the output and the cost line to what your Scrapfly log shows for the same page.

## Frequently asked questions

### What is the best Scrapfly alternative?

It depends on what is driving you off. If it is the credit multipliers, Spider meters usage instead at $1 per GB plus $0.0001 per CPU minute. Rendering bills as compute time, a blocked page usually costs a fraction of a cent, and credits never expire. If it is the need to crawl whole sites, Spider's /crawl endpoint does that in one call, and both tools are worth a run on your own targets.

### Is Scrapfly's 98% success rate real?

Scrapeway's independent run in August 2026 measured Scrapfly at 98% success with a 15.3 second average response, first of nine APIs tested. That agrees with the figure Scrapfly advertises. Treat every vendor-reported success rate with skepticism, including Spider's own 99.9% on our 1,000-URL benchmark, which is not independently verified.

### How many credits does a Scrapfly residential request cost?

25 credits for the residential proxy, plus 5 for JavaScript rendering if you turn it on, plus bandwidth credits after the first megabyte. A rendered residential request lands around 30 credits before bandwidth, as of September 2026.

### Is there a free or open-source Scrapfly alternative?

Scrapfly is closed source with a 1,000 credit free tier. Spider's crawler is MIT licensed at spider-rs/spider and can be self-hosted. The hosted API gives you 2,500 free credits, worth $0.25, if your signup passes our checks. After that you top up from $5 or pay $40 a month on Unlimited.

### Do Scrapfly credits roll over?

Scrapfly sells a monthly quota. Free and Discovery hard-cap when the quota runs out; Pro and above switch to pay as you go in 10,000 credit batches at the plan rate. Spider credits never expire.

## Sources

1. [Scrapfly pricing](https://scrapfly.io/pricing)
2. [Scrapfly billing docs](https://scrapfly.io/docs/billing)
3. [Scrapfly Scrape API credit costs](https://scrapfly.io/docs/scrape-api/billing)
4. [Scrapfly anti-scraping protection](https://scrapfly.io/docs/scrape-api/anti-scraping-protection)
5. [Scrapfly Extraction API](https://scrapfly.io/docs/extraction-api/getting-started)
6. [Scrapfly Screenshot API billing](https://scrapfly.io/docs/screenshot-api/billing)
7. [Scrapfly integrations and SDKs](https://scrapfly.io/integration)
8. [Scrapfly MCP server](https://github.com/scrapfly/scrapfly-mcp)
9. [Scrapeway Scrapfly benchmark, August 2026](https://scrapeway.com/web-scraping-api/scrapfly)
10. [Capterra Scrapfly reviews](https://www.capterra.com/p/212653/Scrapfly/reviews/)
11. [Spider crawler repository (MIT)](https://github.com/spider-rs/spider)
