Firecrawl Alternatives Priced on One Real Job: 20,000 Pages a Month

If your agent or RAG pipeline reads the live web, you need something that loads the page, throws away the nav bar and the cookie banner, and returns Markdown small enough to fit your context budget. Firecrawl made that one API call, which is why so many teams reach for it first.

Firecrawl closed a $75M Series B in September (Smash Capital led it; the news went out September 22, 2026), and it used the moment to ship Alexandria, which it describes as a knowledge library for agents. A funding round is a good excuse to check the bill, so I priced one ordinary job on Firecrawl and eight alternatives. The full write-up, with screenshots and every pricing footnote, is on DevToolLab; this is the condensed version. Short answer: Firecrawl comes to $94 billed month to month, Tavily does the same work for $30, Exa for $20, and Jina Reader for anywhere from $1.51 to $15.77.

How Firecrawl's credit meter works

Everything draws down one credit balance (pricing effective September 4, 2026, which I checked on October 14). Scraping, crawling or mapping a page is 1 credit. Ten search results are 2 credits. Request the JSON, Question or Highlight output formats and each page picks up 4 extra credits, which makes structured output five times the cost of plain Markdown. Even a 403 or 404 response burns a credit.

There are four tiers: 5,000 credits for $19 a month (Hobby), 100,000 for $99 (Standard), 500,000 for $399 (Growth) and 1,000,000 for $749 (Scale). Annual billing cuts roughly 16 to 20 percent, and Hobby users pay $5 for each extra block of 1,000 credits.

That leaves three common reasons to shop around: most of your spend is JSON extraction, search results are all you actually need, or the AGPL-3.0 license clashes with how you would ship a self-hosted copy.

The test job: a weekly re-index of Stripe-sized docs

Picture a support bot that re-reads its documentation every week. On October 14, 2026, the Stripe docs sitemap had 4,946 URLs, and four weekly passes over a site that size add up to roughly 20,000 fetches a month.

Two of these services bill on output size instead of page count, so I pulled 10 pages spread evenly across that sitemap. Through Jina Reader the typical (median) page was 1,511 tokens. One React SDK reference page, though, produced 143,348 tokens by itself and dragged the average to 15,770. The raw HTML came to 922,459 bytes per page on average. The metered math is short enough to check yourself:

const PAGES = 20_000
const JINA_PER_MILLION_TOKENS = 0.05 // Jina Reader output tokens
const SPIDER_PER_GB = 1 // Spider bandwidth, before CPU time

const jinaCost = (tokensPerPage) => ((PAGES * tokensPerPage) / 1e6) * JINA_PER_MILLION_TOKENS
console.log(jinaCost(1_511).toFixed(2)) // 1.51, median page
console.log(jinaCost(15_770).toFixed(2)) // 15.77, mean page
console.log(((PAGES * 922_459) / 1e9 * SPIDER_PER_GB).toFixed(2)) // 18.45

For the plan-based services I used the lowest tier that will hand back Markdown for a public page:

Turn on anti-bot handling, hit JavaScript-heavy pages or ask for JSON and every one of these numbers goes up, and the token and byte meters varied by a factor of ten inside a single site. Committing to a year of Firecrawl Standard brings it down to $83 a month. If you want to plug in your own page count, the original article has the full cost script covering every tier.

Crawl4AI: open source, no meter

Crawl4AI is a Python library under Apache 2.0. It runs a headless browser for you and returns Markdown, and there is no API key and nothing metering your usage. Run pip install -U crawl4ai, then crawl4ai-setup, and use it either as a library or as a Docker server inside your own VPC. If you are scoping for SOC 2 or HIPAA, that is the selling point: pages never leave your network.

What you pay instead is operations work. You deal with the proxies, the CAPTCHAs and the blocked IPs yourself, and growing the browser fleet is your job too. The repo sits at 85,485 GitHub stars, and v0.9.4 came out September 23, 2026. There is also a hosted version that gives you 2,000 free credits, with paid plans starting at $10.

Self-hosting Firecrawl itself

The self-hosting guide in Firecrawl's docs brings up the same API from a Docker Compose file, so your existing client code only needs a new base URL, and nothing is metered. Behind the API and its workers sit Redis, RabbitMQ, FoundationDB, a queue backed by PostgreSQL and Playwright, and the API on port 3002 is the only thing exposed.

Read SELF_HOST.md in the repo before this goes anywhere real. Authentication is off out of the box. The Compose file declares no persistent volumes, so data does not survive recreating the containers. Pages are fetched with the bundled Playwright, and Fire-engine (Firecrawl's scraping engine) and the AI features are a separate setup job. Then there is the license: under AGPL-3.0, a modified copy that you run as a network service has to make its source available to the people using it. The repo has 191,299 stars and is on the v2.11 line, which the guide pins at v2.11.162.

Jina Reader: a URL prefix billed by tokens

Prefix any URL with https://r.jina.ai/ and Jina Reader returns that page as Markdown; s.jina.ai works the same way for a search query. Jina AI joined Elastic in October 2025.

At $50 for 1 billion tokens, or $0.05 per million, nothing metered in this roundup costs less. The rate limit is 20 requests per minute without a key and 500 with one. In April 2026 Jina brought its open source branch (Apache-2.0, 12,147 stars) back in line with what runs in production, so self-hosting gets you the hosted behavior.

The problem is predictability. Knowing how many pages you have tells you almost nothing about the bill: the ten pages I sampled spanned 181 tokens at the low end and 143,348 at the high end. A new key does come with 10 million free tokens, but only for non-commercial work, and each search bills a minimum of 10,000 tokens.

Spider: billed by the gigabyte

Spider sells a crawling API on top of its own crawler, written in Rust and MIT-licensed, and it charges for bandwidth and compute rather than pages: $1 per GB plus $0.0001 per CPU minute. You pay nothing for a failed request, rendering JavaScript shows up as CPU time rather than a price multiplier, and the Unlimited plan charges for concurrent slots instead of requests, from $40 a month for 2.

That model gets expensive on heavy pages. At roughly 922 KB of HTML per Stripe docs page, this job costs $18.45 before CPU time, and zero data retention costs 2.5 times the base rate. The spider crate is at v2.53.9, published September 5, 2026.

Exa: an index that also returns page text

Exa operates a web index of its own, aimed at agents. Give its Contents endpoint a list of URLs and it returns their full text, served from its cache and falling back to a live crawl. The pricing is flat: $1 per 1,000 pages and no plan fee, search between $4 and $15 per 1,000 requests, plus $10 of free credit each month.

The tradeoff is control. You are querying someone else's index rather than steering a crawler, you cannot self-host it, and unless you configure a livecrawl policy you may get a cached copy that trails the live page. It is proprietary.

Tavily: search and extract on one meter

Tavily runs search, extract, map and crawl endpoints off a single credit balance. On February 10, 2026, Nebius said it had agreed to buy the company, and the logo on the site now reads "by Nebius".

A basic Extract call is billed at 1 credit for every 5 URLs that succeed, so 20,000 pages lands exactly on the 4,000 credits in the $30 Project plan. Extractions that fail are not billed, and a basic search costs 1 credit. The downsides: crawls carry an extra mapping fee (1 credit per 10 pages), the advanced extraction depth costs twice as much, and there is no self-hosted option. The free tier is 1,000 credits a month, Bootstrap is $100 for 15,000, and credits past your plan are $0.008 each.

ScrapeGraphAI: describe the data, get JSON

ScrapeGraphAI began life as an MIT-licensed Python library: you give it a page and a plain-English prompt, it sends both to an LLM, and you get JSON back. These days it also sells a hosted API. Structured extraction is the whole point. Each Extract call is 5 credits, which matches what Firecrawl charges for one JSON page, and the library can talk to a local Ollama model, so the extraction never has to leave your machine.

Search is where it gets pricey: every result is 2 credits, so asking for 10 results costs 20. Turning on the "stealth" anti-bot mode tacks 5 credits onto every call. Before the library runs at all you need playwright install and a model. Starter is $20 for 10,000 credits and Growth $100 for 100,000. The library is at v2.3.1, released October 6, 2026.

Browserbase: real browsers for the hard pages

Browserbase is a cloud browser service for agents, and it has added Fetch and Search APIs alongside the browsers. Stagehand, its MIT-licensed framework (25,660 stars, v3.7.3), steers those browsers with natural-language actions. It is the one to pick when the page sits behind a login, a form or a multi-step flow; a page-to-Markdown endpoint cannot do any of those.

For plain Markdown it is the expensive route. On the Developer plan, Fetch returns raw HTML for $1 per 1,000 calls, but Markdown or JSON output is billed as Fetch Extract ($4 per 1,000 calls), and that is what pushes this job to $96. Fetch does not execute JavaScript either, and it has a 5 MB response limit. The Developer plan is $20 a month including 100 browser hours ($0.12 per extra hour); Startup is $99.

The eight at a glance

Picking one without migrating twice

1. Diff the sitemap first. In a typical week most docs pages stay the same. Only send new URLs and pages with a changed lastmod to the API, and every number above shrinks. The Sitemap Diff Checker does that comparison in the browser.
2. Measure ten of your own pages. The token and byte meters moved tenfold on a single site, so a 10-page sample per candidate beats any estimate. Running the same pages through the HTML to Markdown Converter gives you a baseline to judge each API's output against.
3. Find out whether you need JavaScript rendered. Docs that render on the server don't need it; a React dashboard will, and Browserbase Fetch is out at that point.
4. Price structured output separately. Firecrawl charges 5 credits for a JSON page and ScrapeGraphAI 5 for an Extract call. Scraping cheap Markdown and running your own LLM pass over it can undercut both.
5. Check the license before embedding anything. Running a modified Firecrawl as a network service brings AGPL-3.0 obligations with it; Apache-2.0 and MIT code carries no such condition.

What I would use

• Public docs, lowest cost per page: Exa Contents ($1 per 1,000 pages, flat), or Jina Reader once you have measured your pages and confirmed they are short.
• Search first, then read the results: Tavily. A single meter covers both, and the $30 plan absorbed this entire workload.
• Data that must stay in your VPC: Crawl4AI. If your code already speaks Firecrawl's API, self-host Firecrawl instead and set aside time for authentication and persistence.
• Anything behind a login, a form or a single-page app: Browserbase plus Stagehand.
• Already happy with Firecrawl: stay, but know where the lines cross. Paying month to month, Hobby plus pay-as-you-go stays under Standard's $99 up to 21,000 pages, and Standard prepaid yearly ($83 a month) becomes the cheaper choice at around 18,000.

Where this category is heading

The vendors are moving up the stack. Firecrawl is building a knowledge library, Tavily now ships under Nebius, and Browserbase sells search next to its browsers. Meanwhile, turning a page into Markdown is turning into a commodity, priced per page, per token or per gigabyte depending on who you ask. Before you renew, figure out which of those three meters your workload actually rides. The full comparison on DevToolLab has the complete cost script and the screenshots for each service.

References

• 8 Best Firecrawl Alternatives in 2026 (original article on DevToolLab)
• Firecrawl: Introducing Alexandria and the Series B
• Firecrawl pricing
• Firecrawl self-hosting guide
• Crawl4AI on GitHub
• Jina Reader
• Spider
• Exa
• Tavily
• ScrapeGraphAI
• Browserbase