# Firecrawl vs Spider 2026: MCP crawl speed and pricing

Which web crawl MCP has the better crawl speed? On our 1,000-URL run Spider averaged 74 pages a second to Firecrawl's 16. Pricing and licenses compared.

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

Firecrawl is for teams that want a polished TypeScript product with a big community, a schema-driven extract endpoint, and a monthly credit bundle they can put on a card and forget. Spider is a research lab for web data quality. The product is a Rust crawler exposed as an API, and the thing we measure ourselves on is whether the page that comes back is complete and correct, at any volume, on any site. Speed and cost are the evidence for that, and they are what this post spends most of its words on.

The verdict, before the detail. If you fetch under 100,000 pages a month, rarely touch protected sites, and value documentation and ecosystem over raw throughput, Firecrawl is a fine pick and you will not regret it. If your workload is large, spiky, or full of sites that fight back, Spider returns more of the pages you asked for, faster, for a bill that tracks what you used instead of a bundle you have to size in advance. The rest of this page shows the numbers behind both halves of that sentence, with the caveat that the benchmark figures are our own measurements and not independently verified. You can also compare every vendor we track on the [compare page](/compare/).

## Side by side

| Feature            | Spider                                                                                                                                                                             | Firecrawl                                                                                |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Pricing model      | Usage: $1/GB plus $0.0001 per CPU minute, credits never expire                                                                                                                     | Monthly credit bundles, credits expire at period end on self-serve plans                 |
| Entry price        | Pay as you go from $5 in credits; Unlimited concurrency plans from $40/mo                                                                                                          | Free 1,000 credits/mo; Hobby $16/mo yearly, about $19 month to month                     |
| Cost at 100K pages | From $16 on light static pages, $27 to $33 on docs and articles and $138 to $148 on store and reference pages, measured; $40 on Unlimited by our estimate, rendered pages included | $83/mo on yearly billing, about $99 month to month (Standard)                            |
| License            | MIT (spider-rs/spider)                                                                                                                                                             | AGPL-3.0 core, MIT SDKs                                                                  |
| Language           | Rust                                                                                                                                                                               | TypeScript                                                                               |
| Self-host          | Yes, the crawler is the open source crate                                                                                                                                          | Yes, without the hosted anti-bot engine, screenshots, agent or browser tools             |
| MCP server         | Yes                                                                                                                                                                                | Yes, MIT licensed                                                                        |
| SDKs               | Python, JavaScript, Rust, Go, CLI                                                                                                                                                  | Python, Node, Go, Java, Elixir, Rust, Ruby, .NET, PHP                                    |
| Crawl mode         | Synchronous or streamed as JSONL                                                                                                                                                   | Async job ID, poll or webhook                                                            |
| Output formats     | Markdown, commonmark, text, XML, raw HTML, bytes; JSON, JSONL, CSV or XML responses                                                                                                | Markdown, HTML, JSON, screenshot, plus question, highlights, PDF and audio/video formats |

## Firecrawl pricing in 2026

Firecrawl sells credits by the month. One credit is one scraped or crawled page, and add-ons stack on top of that. Here is the lineup as of September 2026, from the [Firecrawl pricing page](https://www.firecrawl.dev/pricing). The page only rendered the “billed yearly” toggle when we read it, so the month-to-month column is derived from the yearly price plus the printed “Save $X” figure, and it matches what two pricing trackers list. Firecrawl’s billing docs confirm both billing periods exist.

| Plan       | Yearly billing, per month | Month to month | Credits per month | Concurrency | Extra credits |
| ---------- | ------------------------- | -------------- | ----------------- | ----------- | ------------- |
| Free       | $0                        | $0             | 1,000             | 2           | none          |
| Hobby      | $16                       | about $19      | 5,000             | 5           | 1,000 per $5  |
| Standard   | $83                       | about $99      | 100,000           | 25          | 2,000 per $5  |
| Growth     | $333                      | about $399     | 500,000           | 50          | 2,500 per $5  |
| Scale      | $599                      | about $749     | 1,000,000         | 100         | 5,000 per $5  |
| Enterprise | custom                    | custom         | custom            | custom      | custom        |

The rules around the table matter as much as the table. Plan credits do not roll over by default. Use 60,000 of Standard’s 100,000 and the other 40,000 are gone at the end of the period. Annual Scale plans keep unused credits for one month and annual Enterprise plans for two. Overage auto-reloads in $5 batches at the plan’s rate, so a Hobby overage credit costs $0.005 and a Scale overage credit $0.001. Rate limits scale with the plan too: 10, 100, 500, 5,000 and 10,000 scrape requests per minute from Free to Scale, and 2, 20, 100, 1,000 and 2,000 crawl requests per minute.

Credit costs per operation, from the [billing docs](https://docs.firecrawl.dev/billing): scrape and crawl are 1 credit per page, map is 1 per call, search is 2 credits per 10 results. JSON extraction adds 4 credits per page, so a structured page costs 5. PDF parsing adds 1 credit per PDF page. Stealth mode, which Firecrawl calls enhanced proxy, now costs the same 1 credit as a basic request, which is a change from the 5 credits older third-party posts still quote. Firecrawl’s extract endpoint bills by tokens at 15 tokens per credit, and its agent runs are dynamic. Most agent runs “consume a few hundred credits” in Firecrawl’s own words.

A worked example. 10,000 basic pages a month does not fit Hobby’s 5,000 credits, so on yearly billing you either step up to Standard at $83 or run Hobby plus five $5 overage packs for $41. 100,000 pages is Standard at $83 on yearly billing. 1,000,000 pages is Scale at $599, because Growth plus 500,000 overage credits comes to $1,333.

## Spider pricing, same volumes

Spider’s published rates are $1 per GB of content transferred and $0.0001 per CPU minute of processing. JavaScript rendering rolls into compute. Standard proxy rotation is included. A blocked page usually costs a fraction of a cent. Credits never expire, and the smallest top-up is $5.

We measured that meter in two runs of 25 pages a kind, on November 6 and November 17, 2026, written up in the [pricing guide](/guides/pricing-and-plans/). 100,000 light static pages cost $16. 100,000 documentation pages and articles cost $27 to $33. Store product pages and reference articles weigh more and cost $138 to $148. At 10,000 pages, divide by ten, which gives $1.60 for light static pages and $2.70 to $3.30 for documentation and articles.

If you would rather have a fixed monthly bill, the [Unlimited plan](/docs/api/unlimited/) sells concurrency instead of pages, from $40 a month for 2 requests at once in http mode. It runs on standard proxy quality, while pay as you go uses our highest quality proxies. Page weight does not change the Unlimited price. What that plan carries depends on how long each request runs. We assume 2.5 seconds, above the 1.5 second median of the plain fetches we [timed on November 16](/blog/how-web-scraping-works/), and a plan busy half the month. On that estimate, which is ours and not a measurement, two http requests at once carry about a million plain pages a month. 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.

Put the two side by side at 100,000 pages. Firecrawl is $83 to $99, against Spider from $16 on pay as you go, or $40 on Unlimited by our estimate, rendered pages included. Pay as you go cost varies by site, and light static pages measured $16 and documentation and articles $27 to $33. At 10,000 pages the gap is larger in ratio terms because Firecrawl’s bundles do not shrink below a plan floor while Spider’s bill does. That is $41 to $44 on Firecrawl, Hobby plus five credit packs on yearly or monthly billing, against Spider from $1.60. At a million pages, Firecrawl’s Scale plan is $599 to $749. Spider is $40 on Unlimited by our estimate for plain fetches in http mode, or from $160 on pay as you go. Pay as you go also starts at 10,000 requests per minute and rises through four levels to 80,000 as the account uses more. Firecrawl allows 500 /scrape requests a minute on Standard and reaches 10,000 only on Scale.

## What both did on the same 1,000 URLs

We ran both APIs over a 1,000-URL corpus in February 2026, split across static pages, JavaScript-heavy apps and sites behind common bot-protection services. The method, URL categories and per-tier results are in the [benchmark post](/blog/firecrawl-vs-crawl4ai-vs-spider-honest-benchmark/). These are our own numbers, not independently verified, and you should treat them as a starting point for your own run rather than a ruling.

| Metric                    | Spider      | Firecrawl  |
| ------------------------- | ----------- | ---------- |
| Success rate              | 99.9%       | 95.7%      |
| Corpus average throughput | 74 pages/s  | 16 pages/s |
| Static HTML throughput    | 182 pages/s | 27 pages/s |
| RAG recall\@5             | 91.5%       | 89.0%      |

The 4.6 point gap in success rate is 46 pages per 1,000. In a retrieval pipeline each of those is a document that never reaches the vector store, and the user who asks about it gets a confident wrong answer. That is why we lead with completeness rather than speed. The throughput gap is widest on static pages, where smart mode fetches over plain HTTP and only opens a browser when the page needs one.

One third-party reading, for balance. Scrapeway’s August 2026 run listed Firecrawl at a 64% success rate, 4.7 seconds average response and $5.18 per 1,000 requests, fourth of nine APIs tested. Their corpus and ours are different, so do not stack the two numbers. We include it because it is the only independent measurement we found.

## Which web crawl MCP is faster

An MCP server is a thin protocol layer over the crawler underneath it, so MCP crawl speed is mostly the speed of the engine it calls. Both Spider and Firecrawl ship MCP servers that expose their own crawl and scrape endpoints, which means the throughput numbers above carry over: 74 pages a second against 16 on the mixed corpus.

Two properties matter more than raw throughput once an agent is driving. The first is how long the tool call blocks, because an MCP call holds the agent’s turn until it returns. The second is whether the crawl returns synchronously. Spider’s MCP crawl returns results directly or streams them as JSONL. Firecrawl’s crawl is async, so the agent polls until the job finishes, and that wall-clock time never shows up in a pages-per-second figure. Firecrawl’s server does cover more ground, with scrape, crawl, map, search, agent and browser tools, and it is MIT licensed even though the core is not. Spider’s server covers the core and AI endpoints; setup is on the [MCP page](/mcp/).

## The AGPL question

This one gets skipped during evaluations and then surfaces in legal review.

| Feature              | Spider       | Firecrawl                                  |
| -------------------- | ------------ | ------------------------------------------ |
| License              | MIT          | AGPL-3.0 (SDKs and some UI components MIT) |
| Commercial use       | Unrestricted | Allowed                                    |
| Modification sharing | Not required | Required if offered as a service           |
| SaaS restriction     | None         | Must publish modifications                 |

Firecrawl’s AGPL-3.0 means that if you modify the source and serve it over a network, which is what building a SaaS on it amounts to, you must release those modifications under the AGPL. For companies building proprietary products on top of the scraping layer, that usually makes the cloud API the only practical path. The self-hosted build also ships without the hosted anti-bot engine, screenshots and actions, the agent, and the browser tools, per Firecrawl’s own self-host guide.

Spider’s crawler is MIT. Modify it, embed it, sell it, no source obligation. If you only consume either cloud API this distinction does not touch you. If self-hosting or building on the open source code is on the roadmap, bring legal in early.

## Where Firecrawl wins

Developer polish is real. The docs are thorough, the API is tidy, the TypeScript SDK has good types, and the crawl, poll, fetch results flow is documented end to end.

Community gravity. The repo had 175,600 stars when we checked in September 2026. That is more blog posts, more Stack Overflow answers, and more engineers on your team who have already used it. When a non-technical stakeholder asks “is this thing safe to bet on”, stars answer the question for you.

SDK breadth. Nine official SDKs, including Java, Elixir, Ruby, .NET and PHP. Spider covers Python, JavaScript, Rust, Go and a CLI, so if your stack is Elixir or .NET, Firecrawl has you covered and we do not.

The map endpoint discovers a site’s URLs for one credit per call without fetching content, which is a cheap way to scope a crawl before paying for it. And schema-driven extract, with Zod or JSON Schema, gives you a typed, repeatable output when you know the shape you want in advance.

## Where Spider wins

Completeness on hard sites. 99.9% against 95.7% on the same corpus, with the caveat above. The gap opens on sites behind common bot-protection services, which is where most production targets live in 2026.

Throughput. 4.6 times the corpus average, and the static-page gap is wider still, because smart mode does not open a browser it does not need.

Billing that tracks usage. No bundle to size, no credits vanishing at month end, no overage packs. A blocked page pays the 0.01 credit page minimum plus the compute it used, which usually comes to a fraction of a cent.

MIT licensing on the crawler, and a live browser. [Spider Browser](/docs/api/browser/) gives you a WebSocket session on a real page with extract, act, observe and agent methods that work on the DOM after clicks and scripts have run. The old sample in this post had a placeholder URL; here is the shape of it:

```typescript
import { SpiderBrowser } from "spider-browser";

const spider = new SpiderBrowser({
  apiKey: process.env.SPIDER_API_KEY,
});

await spider.init();
await spider.page.goto("https://spider.cloud/pricing/");
await spider.page.waitForSelector("table");

const pricing = await spider.page.extract(
  "List every plan name with its price and what it includes"
);
console.log(pricing);
await spider.close();
```

Format flexibility from one parameter. `return_format` gives you markdown, commonmark, plain text, XML, raw HTML or bytes from the same endpoint, and responses can come back as JSON, JSONL, CSV or XML.

## Migration: the same crawl in both SDKs

Crawl a site, get markdown back, print the size of each page.

### Spider

```python
from spider import Spider
import os

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

pages = client.crawl_url(
    "https://spider.cloud/docs/",
    params={
        "limit": 10,
        "return_format": "markdown",
        "request": "smart",
    },
)

for page in pages:
    print(f"{page['url']}: {len(page.get('content', ''))} chars")
```

### Firecrawl

```python
from firecrawl import FirecrawlApp

app = FirecrawlApp(api_key="fc-YOUR_API_KEY")

result = app.crawl_url(
    "https://spider.cloud/docs/",
    params={
        "limit": 10,
        "scrapeOptions": {
            "formats": ["markdown"],
        },
    },
    poll_interval=2,
)

for page in result.get("data", []):
    print(f"{page['metadata']['url']}: {len(page.get('markdown', ''))} chars")
```

The two calls look alike. The difference is underneath: Firecrawl’s crawl is a job you poll or subscribe to with a webhook, while Spider’s `/crawl` returns the pages in the response or streams them. The parameters, request modes and streaming options are on the [crawl endpoint docs](/docs/api/crawl/).

## When to pick which

Pick Firecrawl when your volume is moderate, your targets are mostly cooperative, your team already lives in its ecosystem, or you want schema-driven extraction with deterministic output and a monthly bill that never surprises you. Pick it too if your language is one Spider does not cover.

Pick Spider when completeness on protected sites is the requirement, when throughput at scale is the requirement, when the bill needs to follow usage instead of a plan floor, or when MIT licensing on the crawler matters for what you are building. The same choice comes up with the other tools in this series; see [Spider vs Crawl4AI](/blog/spider-vs-crawl4ai/) for the self-hosted case and [Spider vs Jina Reader](/blog/spider-vs-jina-reader/) for the single-URL case, or the wider [best Firecrawl alternatives](/blog/best-firecrawl-alternatives/) roundup.

Both are production tools with active teams behind them. The cheapest way to settle it for your own targets is to run the same URL through the [playground](/playground/) and look at what comes back.

## Frequently asked questions

### Is Firecrawl free?

Firecrawl's free plan gives 1,000 credits a month with no card, at 2 concurrent requests and 10 scrape requests per minute. Paid plans start at $16 a month billed yearly (about $19 month to month) for 5,000 credits, as of September 2026.

### How does Firecrawl pricing compare to Spider?

Firecrawl sells monthly credit bundles, and 100,000 credits cost $83 a month on yearly billing. Spider bills usage at $1 per GB plus $0.0001 per CPU minute. Measured, 100,000 pages cost from $16, and the cost varies by site. Light static pages came to $16 and documentation pages and articles $27 to $33. A blocked page usually costs a fraction of a cent. Spider's Unlimited plan is $40 a month for 2 requests at once in http mode, and page weight does not change that price. See the Spider pricing guide at /guides/pricing-and-plans/.

### Can Firecrawl be self-hosted?

Yes. Firecrawl publishes a self-host guide and the core repo is AGPL-3.0. The self-hosted build leaves out the hosted anti-bot engine, screenshots and actions, the agent, and the browser tools, so protected sites are harder to reach than on the cloud API.

### What is the best open-source alternative to Firecrawl?

It depends on what you want to own. Spider's crawler (spider-rs/spider) is MIT licensed and written in Rust, so you can embed it in a commercial product without the AGPL obligations that Firecrawl's core carries. Crawl4AI is another option if you want a Python framework on your own machines.

### Which web crawl MCP has the better crawl speed?

An MCP server is a thin layer over the crawler behind it, so the engine sets the speed. On our own 1,000-URL run in February 2026, Spider averaged 74 pages a second against Firecrawl's 16, and 182 against 27 on static HTML. Spider's MCP crawl also returns results directly or as streamed JSONL, while Firecrawl's crawl is async and the agent polls until the job finishes.

### Does Firecrawl support MCP?

Yes. Firecrawl ships an MIT-licensed MCP server with scrape, crawl, map, search, agent and browser tools. Spider has an MCP server too, and because MCP is a thin layer over the API underneath, the speed and sync-vs-async behavior of each API carry straight into the agent loop.

### Do Firecrawl credits roll over?

Not on self-serve plans. Firecrawl's billing docs say plan credits do not roll over by default; annual Scale plans roll unused credits over one month and annual Enterprise plans two months. Spider credits never expire.

## Sources

1. [Firecrawl pricing](https://www.firecrawl.dev/pricing)
2. [Firecrawl billing and credit costs](https://docs.firecrawl.dev/billing)
3. [Firecrawl rate limits](https://docs.firecrawl.dev/rate-limits)
4. [Firecrawl stealth mode pricing](https://docs.firecrawl.dev/features/stealth-mode)
5. [Firecrawl self-hosting guide](https://docs.firecrawl.dev/contributing/self-host)
6. [Firecrawl repository and license](https://github.com/firecrawl/firecrawl)
7. [Firecrawl MCP server](https://github.com/firecrawl/firecrawl-mcp-server)
8. [Scrapeway Firecrawl benchmark, August 2026](https://scrapeway.com/web-scraping-api/firecrawl)
9. [Spider crawler repository (MIT)](https://github.com/spider-rs/spider)
