Firecrawl Alternatives: No Credits, Runs Locally

Firecrawl’s free plan hands you 1,000 credits a month, and a single 1,000-page site crawl spends all of them. That arithmetic sends a lot of people looking for a Firecrawl alternative, and the good news is that the job it does, fetch pages, clean them to LLM-ready markdown, crawl and extract at scale, is now covered by tools that either bill a flat price or bill nothing at all. I ran the two local options end to end today and pulled the credit numbers from Firecrawl’s own pricing page (checked October 16, 2026). Here is what each route costs, where it breaks, and who should pick it.

The verdict first

If you want zero credits and zero servers, the two honest choices are Crawl4AI (a free Python library) and Magpie (a local CLI plus desktop app). If you want Firecrawl’s exact API shape without the bill, self-host it and accept the feature cuts. If you just need URL-to-markdown behind a quick HTTP call, Jina Reader’s free tier is hard to beat. Other hosted APIs (Tavily, Spider, Bright Data) swap Firecrawl’s meter for their own, so they are not the answer to this page’s question and get no entry here. Firecrawl cloud itself stays the right pick for one specific case, covered at the end.

Route	Runs where	Price	Markdown for LLMs	JS rendering	Structured extraction	Watch mode	Best for
Firecrawl cloud (baseline)	Hosted API	Free 1,000 credits/mo; $19–83+/mo	Yes	Yes, managed	JSON formats +4 credits/page	Monitor (bills per check)	Teams that want zero infrastructure and pay per page
Magpie	Local binary (CLI + desktop app)	CLI free (AGPL-3.0 or commercial); Desktop: 5 free runs, then $49/mo flat	Yes	Yes, go-rod + click/scroll actions + XHR capture	Schema through any LLM, incl. Ollama; 27 zero-LLM verticals	Yes, webhooks included	Local-first scraping at a flat price
Crawl4AI	Your Python process or Docker	Free, Apache-2.0	Yes	Yes, Playwright	CSS/XPath/regex or LLM strategy	No	Python developers who want code control
Firecrawl self-hosted	Your Docker stack (5 services)	Free code; you own the ops	Yes	Partial: no Fire-engine, no screenshots or actions	Bring your own LLM key (OpenAI-compatible or Ollama)	No	Keeping the API contract, losing the bill
Jina Reader	Hosted endpoint	Free without a key at 20 req/min; 100 RPM with a free key	Yes	Yes	No	No	One-shot URL-to-markdown from scripts and agents
Scrapy	Your Python process	Free, BSD	No, you add a converter	Via Playwright integration	CSS/XPath pipelines you build	No	Large custom crawls with custom pipelines
Playwright + trafilatura	Your Python process	Free (both Apache-2.0)	Via trafilatura	Yes, you drive the browser	You write it	No	One-off scripts where a framework is overkill

Ranking logic: local and flat-price options first, because that is the problem this page solves. Every claim below comes from Firecrawl’s published pricing (effective September 4, 2026 per their page), their self-hosting docs (v2.11.162), or runs I executed today on a home connection.

What Firecrawl gets right

The reason Firecrawl got popular is real. One POST to /v1/scrape with a Bearer token returns cleaned markdown, and you never think about Chrome, proxies, or queues. The managed browser fleet handles JavaScript pages, the API stays stable across breaking-site seasons, and it ships an MCP server, so AI tools can call it directly. Crawl, map, and search sit behind the same authentication. If your team measures engineering hours, not page counts, paying for that is defensible.

Two design choices show up in the credit meter, though, and both push cost up as you scale.

Where the credits bite

Firecrawl’s pricing page lists every rate on one table, which I appreciate, because the math is uncomfortable once you run it:

• Scrape, crawl, and map bill 1 credit per page. A 10,000-page docs crawl is 10,000 credits. Do it weekly and that is 40,000 credits a month, 40% of the $83/mo Standard plan (billed annually, 100,000 credits).
• JSON, Question, and Highlight formats add 4 credits per page. Extract structured data from the same 10,000 pages and the month’s spend becomes 80,000 credits, 80% of Standard. Overage on Standard is $5 per 2,000 credits ($0.0025 apiece), so crawling past your allocation has a visible price tag, not a surprise one, which is at least honest.
• Error pages still cost 1 credit. A 404 or 403 response bills the same as a clean scrape. Only scrapes that return no result are free.
• The free tier is thin for anything recurring. 1,000 credits a month, 2 concurrent browsers, and 2 overall requests per minute. One full-size crawl eats the month; the rate caps make interactive use slow.
• Everything transits their cloud. Your URLs and the page contents come back through Firecrawl’s servers. For public docs that is a shrug; for anything behind a login or under an NDA, it is a compliance conversation.

None of this makes Firecrawl a bad product. It makes it a metered one, and meters reward the alternatives below.

The six Firecrawl alternatives

1. Magpie: local, flat-price, no credit meter

Magpie runs the same pipeline shape as Firecrawl (scrape to markdown, crawl, map, schema-driven extraction, watch with webhooks) as a single static Go binary on your machine, driven by a CLI or a desktop app. The core CLI is a free download, AGPL-3.0-or-later or a commercial licence. The desktop app gives you 5 free runs per install, then $49/month for one computer, and a crawl costs 1 run whether it covers 12 pages or 12,000. Failed and stopped runs are free. There is no per-page counter anywhere.

I ran it against the same sandboxes this morning:

# one page to clean markdown
magpie scrape https://quotes.toscrape.com/ --page-format markdown
# 2.2 seconds, zero credits

# a 12-page crawl with zero LLM calls
magpie crawl https://books.toscrape.com/ --max-pages 12 --corpus --rate 1.0 --out books.jsonl
# pages_ok=12, 12.0 seconds at 1 req/s politeness rate

# sitemap URL discovery, no LLM
magpie map https://scrapy.org
# 9 URLs printed, one per line

JavaScript pages work through local browser rendering with actions. On the infinite-scroll test page, a static fetch returns nothing (Magpie’s quality gate refuses it as empty), while the same URL rendered with three scroll-and-wait passes produced 1,202 words in 17.5 seconds:

magpie scrape https://the-internet.herokuapp.com/infinite_scroll \
  --render browser \
  --action 'scroll 2500' --action 'wait 700' \
  --action 'scroll 2500' --action 'wait 700' \
  --action 'scroll 2500' \
  --page-format text

Where Firecrawl needs its +4-credit JSON formats for structure, Magpie takes a JSON Schema and sends the page through any LLM provider you configure, including a local Ollama model, so extraction can run with no API key at all. Twenty-seven zero-LLM verticals (article, job posting, event, product, RSS, and more) skip the model entirely. There is also a 13-tool MCP server, login sessions with persisted cookies, XHR capture for hidden APIs, robots.txt respect with auto-throttle, and a proxy pool with failover. The full JS-rendering workflow is in how to scrape dynamic websites, and the politeness settings are covered in scraping without getting blocked.

The honest cons: there is no hosted API, so nothing runs when your machine does not (if you want a managed service instead, that is the Apify alternative question). It does not bypass CAPTCHAs or bot walls, by design, and it cannot extract from the walled gardens (Google Maps, Instagram, LinkedIn behind login, and friends). The $49/month desktop licence is real money against a free Python library, though the CLI is free if you live in a terminal.

2. Crawl4AI: the free local library

Crawl4AI (v0.9.5, October 14, 2026, Apache-2.0) does Firecrawl’s core job locally: it fetches with a real browser, returns LLM-ready markdown, and crawls with configurable depth and filters. It installs with pip, runs inside your own Python process, and takes extraction strategies from CSS selectors up to LLM calls against any provider. Deep crawling, stealth mode, proxies, and screenshots are built in.

from crawl4ai import AsyncWebCrawler

async with AsyncWebCrawler() as crawler:
    result = await crawler.arun("https://quotes.toscrape.com/")
    print(result.markdown)

Cons: it is Python and you are the operations team. Browser RAM, politeness pacing, retries, and output storage are your code. There is no GUI and no watch mode; change detection is a cron job you write. The dedicated Crawl4AI page goes deeper on setup and limits. For a Python shop, though, free beats $83 every month.

3. Firecrawl self-hosted: the API without the meter

You can run Firecrawl’s own code locally, and their self-hosting docs are upfront about what that buys. The default stack is five Docker services (API, Postgres, Redis, RabbitMQ, and a Playwright service) serving scrape, crawl, map, and search on port 3002. What does not come along: Fire-engine, their anti-bot layer, is not included; screenshots and page actions report unsupported in the default stack; LLM-backed extraction only works once you wire in your own OpenAI-compatible endpoint or Ollama; and authentication is off by default, with the docs warning plainly that “no single .env switch makes the stack production-ready” (the compose file also defines no durable volumes, so backups are your project).

git clone https://github.com/firecrawl/firecrawl.git
cd firecrawl
# in the .env the self-host docs create: USE_DB_AUTHENTICATION=false + Postgres credentials
docker compose up -d    # API on http://localhost:3002

(Their docs pin release v2.11.162 and walk the exact env setup; the snippet above is the shape, not the full procedure.)

As a Firecrawl alternative this is the most faithful one, same API contract, no credits, and it is the right pick if your code already speaks Firecrawl. The cons are the ops burden of a five-container stateful stack versus one binary, the missing anti-bot layer, and the fact that you have just rebuilt the infrastructure Firecrawl’s fee was paying for. If self-managing Docker services sounds like the job you were escaping, this is not your exit.

4. Jina Reader: the cheapest managed route

Jina’s Reader converts any URL to markdown through https://r.jina.ai/<url>. Without an API key it is free at 20 requests per minute; a free key raises that to 100 RPM with a 100K tokens-per-minute cap. For feeding an agent a handful of pages, it is the shortest path that involves no installation at all:

curl -s "https://r.jina.ai/https://quotes.toscrape.com/" | head -40

Cons: it is a reader, not a platform. No crawling with depth budgets, no structured extraction endpoint, no watch mode, no login sessions, and the data still flows through a third-party cloud. Rate limits and throughput, not features, will be your ceiling. But at zero dollars and one curl, nothing else on this page is simpler.

5. Scrapy: the free classic, if you will write code

Scrapy (BSD-licensed, the framework behind a decade of production crawlers) has no credit meter because there is no meter at all: it runs in your process and scales as wide as your hardware and politeness settings allow. Fifteen years of middleware, autothrottling, and pipeline extensions exist for the taking.

The cons relative to Firecrawl are the shape of the work: you write spiders in Python, and there is no markdown-for-LLM output by default, you bolt on a converter, and you build the extraction contracts yourself. For AI-pipeline work you are assembling a toolkit that Firecrawl and the first two options ship as a product. For a 500,000-URL archive crawl with custom retry and storage rules, Scrapy remains the right answer and always will.

6. Playwright plus trafilatura: the DIY floor

The zero-dependency version of “Firecrawl at home” is two libraries: Playwright to render the page (Apache-2.0) and trafilatura to cut the boilerplate out of it. Twenty lines get you the same clean-article markdown Firecrawl returns, for the price of a Python import:

from playwright.sync_api import sync_playwright
import trafilatura

url = "https://quotes.toscrape.com/"
with sync_playwright() as p:
    page = p.chromium.launch().new_page()
    page.goto(url)
    html = page.content()
print(trafilatura.extract(html, output_format="markdown"))

Cons: this is a floor, not a stack. No crawling, no retries, no caching, no sessions, no schema extraction, and every site-specific quirk becomes your bug. Worth it for one-off scripts; not worth it past about a dozen pages, at which point you have re-derived Crawl4AI’s feature list the hard way.

Pricing reality check

Same job, four ways. Suppose you crawl a 10,000-page docs site once a week and want structured output from every page:

Route	Monthly cost for that job	Notes
Firecrawl cloud, Standard	80,000 credits against the 100,000-credit plan ($83/mo annual)	JSON formats at +4/page quadruple the base 40,000; overage $5 per 2,000 credits
Magpie Desktop	$49 flat, 4 runs	Page count does not change the run count; CLI route is $0
Crawl4AI	$0	Your hardware, your LLM key only if you use extraction
Firecrawl self-hosted	$0 credits, one VPS + your LLM key	Five containers to keep alive; no Fire-engine

Watching pages tips it further. Firecrawl’s table bills Monitor per check (7 credits per page per check on its deterministic engine), so a handful of watched pages checked hourly compounds fast; Magpie’s watch mode and Crawl4AI’s nothing both bill the same as sitting idle.

Who should stay on Firecrawl

One case justifies the meter: you need unblocking and browser work at scale, on someone else’s infrastructure, with an SLA-shaped API in front. Fire-engine exists because sites fight back, and fighting back is exactly what Magpie refuses to do by design and what your self-hosted stack cannot do at all. If your crawls die to bot walls daily and you would rather pay than engineer, Firecrawl cloud is the sensible choice and this page is not an argument, just a price list.

FAQ

Is Firecrawl free? The free plan gives 1,000 credits per month. At 1 credit per page, that is one 1,000-page crawl or a thousand single scrapes a month, with 2 concurrent browsers and 2 overall requests per minute.

What is the cheapest Firecrawl alternative? Crawl4AI and self-hosted Firecrawl cost $0 in code (your hardware and time aside), and Magpie’s CLI is a free download. Among hosted services, Jina Reader’s keyless 20 RPM tier is the only genuinely free always-on option.

Can I self-host Firecrawl? Yes. Scrape, crawl, map, and search work in the default Docker stack. Fire-engine, screenshots, page actions, and auth do not, and the docs themselves call the baseline non-production.

Does Magpie work like Firecrawl? Same pipeline shape (scrape, crawl, map, extract, watch, MCP), different trust model: a local binary where data never leaves your machine, flat pricing instead of credits. No hosted API, and no bot-protection bypass.

Do failed scrapes cost credits on Firecrawl? Scrapes that return no result are not charged. A 403 or 404 response still costs 1 credit, which matters when crawling sites with lots of dead URLs.

Pick by the shape of your week

If your scraping lives in cron jobs and scripts on hardware you control, run the two locals back to back today: pip install crawl4ai if you want a library, magpie scrape <url> --page-format markdown if you want a tool. If the credit math above looks like your invoice, rerun your biggest crawl through whichever one survives, and compare the output page by page against Firecrawl’s before your next billing date decides for you.