Firecrawl Audited: 206,201 Stars, a 0.1.1 Local Binary With 4,252 Downloads, 810 Tags Since the Last Release, and 6 of 66 v2 Paths Served Locally

Firecrawl has 206,201 stars, but its Local binary is 0.1.1 with 4,252 downloads, serves 6 of 66 v2 paths, and 810 tags followed its last release.

Firecrawl’s GitHub page opens with a sentence that has nothing to do with scraping source code: “Knowledge infrastructure to make your agents smarter. Search, scrape and access 550+ data providers through one API.” That sentence describes Firecrawl Alexandria, a hosted data library with 550+ providers, 250M+ people, 75M+ companies and 41M+ research papers. Alexandria is not in the repository. The repository’s own README says so in one line: “Alexandria runs on Firecrawl Cloud, so the self-hosted server does not include it.”

That gap is the whole story of this repository, and it is not a scandal — it is a product strategy with unusually honest footnotes. The interesting part for anyone deciding whether to adopt Firecrawl is that the footnotes are not where most people look. They are in SELF_HOST.md, in apps/local/README.md, in a code comment inside serve.rs, and in the tag list.

I measured the repo on 2026-11-22 UTC against commit 1fcb57c3 (the commit PyPI’s attestation points to for firecrawl-py 4.57.0’s build), plus the GitHub API, PyPI, npm and crates.io. Everything below is a count, a date, or a quoted line. I did not build the Rust binary: this host has no Rust toolchain, so the Local numbers come from source, the crate metadata, and the project’s own limits section. I say so again where it matters.

The inventory behind 206,201 stars

MetricValue
Stars206,201
Watchers (subscribers_count)507 (0.25% of stars)
Forks10,780 (5.23%)
Open issues + PRs908
Created2024-04-15
LicenseAGPL-3.0 (repo), MIT (SDKs, PyPI package)
Files in the tree2,208
TypeScript in apps/api/src1,078 files, 304,154 lines
Test files in apps/api/src457, containing 4,610 it()/test() declarations
SDKs9 (Python, JS, Go, Rust, PHP, Ruby, .NET, Java, Elixir)
Tags902
GitHub Releases35 (latest: v2.11.0, 2026-06-19)
Top contributor share28.4% of commits (top five: 73.9%)

A 0.25% watcher-to-star ratio is low but not anomalous for a project that went through GitHub Trending repeatedly. The number that matters more is the ratio between 304,154 lines of API code and 4,610 test declarations: whatever else is true, this is not a thin wrapper around a scraping library. The repository is a real server with queues, workers, a Playwright service, PostgreSQL, Redis and RabbitMQ.

It is also, as of this month, three products shipped from one tree at three very different maturity levels.

Three delivery paths, three maturity levels

The README’s own framing:

PathWhat it isWhere it runs
Firecrawl LocalOne Rust binary; scrape, crawl, map, batch scrape, MCP server, and a local v2 APIYour machine
Self-hostingThe full apps/api server with queues, workers and databasesYour infrastructure
Firecrawl CloudHosted service, plus search, Alexandria, Interact, Agent, Monitorfirecrawl.dev

The maturity gap is visible in the registries:

ArtifactRegistryVersionAge / downloads
firecrawl-localcrates.io0.1.1published 2026-11-11, 2 versions, 4,252 downloads
firecrawl-pyPyPI4.57.0first publish 2024-04-12, 220 releases
firecrawl (JS)npm4.54.0210 versions
@mendable/firecrawl-jsnpm4.54.0289 versions (legacy name)
firecrawl-mcpnpm3.41.0145 versions
firecrawl-clinpm1.30.0164 versions

The binary that the README leads with — “Run Firecrawl on your own machine as one binary” — is eleven days old, pre-1.0, and has been downloaded 4,252 times. The Python SDK has had 220 releases over two and a half years. Those are not the same product, and treating the 206,201 stars as evidence about the binary is exactly the mistake the star count invites.

The crate page gives its own scale: 9.9K SLoC, 125 KiB. That 125 KiB is the package size, which is part of the pitch — one binary, no database, no queue, no container.

“Code written for Firecrawl runs against it unchanged”

This sentence appears in the README, in apps/local/README.md, and on the crates.io page. It is the most load-bearing claim in the Local product, so it is worth measuring.

The v2 router registers 146 get/post/put/delete calls over 66 distinct paths. They break down like this:

First path segmentDistinct paths
team12
monitor7
slack7
agent6
crawl6
computer4
parse4
scrape, keyless, batch3 each
search, extract, alexandria, support2 each
map, feedback, concurrency-check1 each

apps/local/src/serve.rs registers nine routes:

.route("/v2/scrape", post(scrape_handler))
.route("/v2/map", post(map_handler))
.route("/v2/crawl", post(crawl_handler))
.route("/v2/crawl/{id}", get(job_status))
.route("/v2/crawl/{id}", delete(job_cancel))
.route("/v2/batch/scrape", post(batch_handler))
.route("/v2/batch/scrape/{id}", get(job_status))
.route("/v2/batch/scrape/{id}", delete(job_cancel))
.route("/health", get(health))

That is six v2 path entries out of 66, plus /health. Laid against the SDK surface, the Python client exposes 77 public methods, the JS client 71, and the Go client 50. Four operations — scrape, crawl, map, batch scrape — run locally.

The documentation is explicit about where the rest goes: “Every other /v2 route, such as /v2/search, is passed on to Firecrawl Cloud, unless FIRECRAWL_CLOUD says otherwise.” And on the pass-through path, the API key travels with the request. So “unchanged” means your client library and your call sites do not change. It does not mean the code runs on your machine. A team that reads the sentence, points api_url at localhost:3002, and assumes the bill and the network traffic are now local has understood three words and missed the sentence’s subject.

The limits section is more forthcoming than the headline, and this is where Firecrawl deserves credit rather than criticism:

Local limitationExact wordingSilent or loud?
json and summary formats“Local scrapes skip the json and summary formats with a warning”Returns success, no structured output
Browser actions“ignore browser actions”Ignored
Job lifetime“Crawl and batch jobs live in memory and expire an hour after they start”Jobs vanish on restart
Legacy routes“The v0 and v1 API routes are not served”404
JS rendering“Without one, static pages still work and a page that needed a browser comes back with a warning”Warning
Docker“Chrome keeps its sandbox on, which needs user namespaces, and Docker’s default seccomp profile blocks them”Render fails

The first row is the one to design around. An extraction pipeline that depends on formats: ["json"] with a schema will keep receiving HTTP 200 from Local and keep receiving no JSON. The warning is there, but warnings do not fail jobs, retries, or nightly reports.

The cloud hand-off is disclosed, metered, and unidentified in size

Local’s default FIRECRAWL_CLOUD=auto sends three things to Firecrawl’s servers: search, pages that refuse the local fetch, and Alexandria calls. The docs describe each:

  • Search: “There is no search index on your machine”, and keyless search is “rate limited”.
  • Blocked pages: “When a site blocks both the plain fetch and the local browser, Firecrawl Cloud fetches it”, and the returned document carries "source": "firecrawl-cloud".
  • Alexandria: “The providers run on Firecrawl Cloud”, needs a free account.

Two details are easy to miss and matter for a privacy-sensitive deployment. First: “Cloud calls carry a random install ID and the name of the tool that made them, which is how Firecrawl counts installs.” Second: when the cloud also fails, the response has "blocked": true plus a warning. The fallback is documented, tagged in the response, and can be switched off with FIRECRAWL_CLOUD=off (any unrecognised value counts as off, which is a sensible failure mode).

What is not documented is the size of the keyless allowance. Across the README, SELF_HOST.md and the Local README, the phrase is “at a limited rate” and nothing else — no requests per minute, no daily cap, no per-IP rule. For a design decision (“can we ship this to a team without anyone signing in?”), the only honest answer from the docs is: measure it in your own environment. Any number quoted by a blog post, this one included, would be a guess.

The MCP path is where the split becomes visible to an agent

firecrawl-local mcp starts the local API on a loopback port and then runs the firecrawl-mcp npm package — 145 published versions, latest 3.41.0 — against it. The tools an agent sees are the standard Firecrawl tools; where each one executes depends on which list it is in:

Tool familyRuns onNote
scrape, crawl, map, batch scrapeYour machineNo API key for the local routes
searchFirecrawl CloudKeyless, rate-limited; no number published
Alexandria (find-tools, provider calls)Firecrawl CloudRequires firecrawl-local login
Interact, Agent, Monitor, Parse (uploaded files)Firecrawl CloudNot implemented locally at all

firecrawl-local init finds Claude Code, Claude Desktop, Cursor, Windsurf, Gemini CLI and Codex and adds the server to each, “backs up every config file first”. The security note attached to the MCP path is unusually specific: “An AI agent that reads a page with hidden instructions could be steered into opening an internal URL. If your agent browses sites you do not trust, register the MCP server as firecrawl-local mcp --public-only.”

That is the right warning to print, and it points at the structural fact of this design. The split between local and cloud is not a deployment detail the agent can see. The tool names are the same, the schemas are the same, and the only difference is a "source": "firecrawl-cloud" field in results that most agents will never surface to a user. If you want the boundary to be legible in logs, you have to check that field yourself.

The economics follow the same line. Alexandria is described as “Discovery is free, and running a tool uses the credits listed on it” — 550+ providers priced per call, discovered for nothing. Local scraping is free forever. That is a coherent funnel: free local scraping, free provider discovery, paid provider execution, paid scale. Whether it is a good deal depends entirely on how often your workload hits a blocked page or needs a provider, which returns to the same instruction: measure the blocked rate before you commit to a budget.

Self-hosting: a real server, with the operational decisions left to you

SELF_HOST.md is the most valuable file in the repository, because it reads like an internal pre-flight checklist that someone decided to publish. It states plainly:

  • “The default API is unauthenticated.”
  • “The root Compose file defines no persistent volumes” for NuQ PostgreSQL, Redis and RabbitMQ.
  • “the bundled pg_cron configuration targets the default postgres database”.
  • “AI-backed features: no model provider” — you connect OpenAI, an OpenAI-compatible endpoint, or Ollama.
  • “Scraping: bundled Playwright with basic fetch fallback” — a separate engine such as Fire-engine is optional.
  • “The checked-in Compose file is a source-aligned starting point, not a production architecture.”

Two more structural facts sit behind those lines. First, docker-compose.yaml defaults to build: for the API, the Playwright service and the NuQ Postgres image; the ghcr.io/firecrawl/* images are present but commented out. A first run compiles the stack. Second, fire-engine — the anti-bot engine referred to 32 times as FIRE_ENGINE_BETA_URL and friends in apps/api/src — is not in this repository. The project says so indirectly but precisely, in AGENTS.md, which tells contributors how to gate tests: “If it requires fire-engine: !process.env.TEST_SUITE_SELF_HOSTED”. There are 14 test files and 23 occurrences of that variable in the API source.

So the self-hosted edition inherits 304,154 lines of server code and its 4,610 test declarations, minus the ones that assume infrastructure you do not have. That is a normal open-core arrangement. It does mean the phrase “full Firecrawl server” deserves a modifier: it is the full server minus the hosted scraping engine and minus Alexandria, which is where the 550+ providers live.

Nine SDKs, six major version lines

Here is a table that should surprise anyone who assumes an SDK version describes an API generation:

LanguageVersion in repoRegistry latestPublic methods counted
Python4.58.04.57.0 (PyPI)77
JavaScript/TypeScript4.55.04.54.0 (npm)71
Rust2.21.10——
Elixir2.0.0——
Java1.18.9——
Ruby1.17.8——
PHP1.16.7——
Go1.16.11—50
.NET1.15.3——

Nine SDKs sit on six different major numbers — 4, 2, 2, 1, 1, 1, 1, 1, 1 — for one API. The Python and JS packages are one patch ahead of what is published; that is normal for a monorepo where the version file changes in the same PR as the feature.

The practical consequence is that “we’re on Firecrawl v4” is not a statement you can make across a polyglot stack. A Go service on 1.16.11 and a Python worker on 4.58.0 are both current, and their feature sets differ by whatever landed between those lines: the Go client has 50 public methods against Python’s 77, and the difference is not mostly naming — it includes the monitoring, agent and computer-browser families that the Python client exposes.

If you need one number to put in a design doc, do not use the SDK version. Use the endpoint list you actually call, and check it against apps/api/src/routes/v2.ts — 66 paths is the whole surface, and no single SDK covers all of it.

902 tags, 35 releases, and a release page five months old

The release engineering has drifted into an unusual shape:

SignalValue
Tags902
Newest tagv2.11.810, commit 2026-11-21 14:21 UTC
Latest GitHub Releasev2.11.0, published 2026-06-19
Tags cut since that release810
Releases, all time35 (oldest v1.0.0, 2024-09-05)
Release assets on the latest release0

The patch number is a merge counter. v2.11.0 was “feat: unfreeze node (#3826)”; five months and 810 merges later the tag is v2.11.810, whose message is “feat(api): x-firecrawl-work-contact-only leaves personal contact fields out of p…”. Nothing in the tag name tells you whether a patch changed a response schema or a typo in a log line.

For a self-hoster this is the operational detail that costs real hours. Pinning is possible — the tags are real and the Compose file can reference one — but “what changed between 2.11.412 and 2.11.810” cannot be answered from GitHub Releases, and there is no changelog in the repository that enumerates them. The nightly firecrawl.dev/changelog page is the product changelog, not a per-tag diff.

Compare the registries: PyPI has 220 releases, the JS package 210 under the new name and 289 under the old one, firecrawl-mcp 145, firecrawl-cli 164. That is a lot of publishing machinery attached to a project whose canonical release page stopped updating in June.

What the licence actually says

The README: “This project is primarily licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). The SDKs and some UI components are licensed under the MIT License.” The registries agree: firecrawl-local is AGPL-3.0 on crates.io, firecrawl-py is MIT on PyPI.

AGPL-3.0 is the network copyleft licence. Running it internally does not, by itself, oblige you to publish anything; exposing a modified version to users over a network does. Two practical consequences for teams:

  1. Wrapping it behind your own API and selling access is the scenario the licence is designed to reach. The MIT SDKs do not change that, because they call the AGPL server.
  2. Patching apps/api for your own use is fine, but the patch becomes something you must be able to offer to network users of your deployment.

The repo does not state whether a commercial licence is available for the server; that question goes to the vendor, not the README.

What holds up

An audit that only lists gaps is not an audit, and several things here are better than the average 200k-star project:

ClaimEvidence
Local shares cleaning code with the API“Firecrawl Local compiles the HTML cleaning code in apps/api/native/src directly, so a change there changes both the API and Firecrawl Local.”
Local’s security defaults are thought throughChrome runs “headless and sandboxed with a throwaway profile, behind a loopback proxy”; link-local and cloud metadata addresses “are blocked in every mode, including after redirects and DNS resolution”; serve refuses a non-loopback bind without a token
Crawling respects robots.txt“Firecrawl Local identifies itself in its User-Agent and reads robots.txt when crawling, where site owners can address it as FirecrawlLocal.”
Supply chain is attestedPyPI verified the 4.57.0 artifact as built by GitHub Actions from commit 1fcb57c3
Docs admit the ugly partsunauthenticated default, no persistent volumes, in-memory jobs, skipped formats, stale pg_cron target — all written down

The pattern is consistent: the documentation is candid and the marketing surface is not. The README’s cloud section claims “Covers 96% of the web” and “P95 latency of 3.4s across millions of pages”, both pointing at an external blog post; neither figure is accompanied by any benchmark for Local or self-hosted deployments, where the baseline is “bundled Playwright with basic fetch fallback”.

What to verify before you adopt it

If you are evaluating Firecrawl this month, these checks take an afternoon and replace every number in this article with one about your own workload:

  1. Pick your formats deliberately. Scrape ten of your real URLs through Local with formats: ["json"] and confirm what comes back. A 200 with no json key is the failure mode the docs warn about and jobs do not catch.
  2. Count your endpoint usage. List the endpoints your code calls and check them against the six Local path entries. Anything outside scrape/map/crawl/batch is a cloud call.
  3. Decide the fallback question explicitly. Set FIRECRAWL_CLOUD=off in a staging run and see which of your pages fail. That set is what you are actually outsourcing today, plus the install-ID-bearing requests.
  4. Budget the fallback. Every blocked page in auto mode is a cloud call attributed to you. Measure the blocked rate on your target sites before promising a cost per 1,000 pages.
  5. For self-hosting, diff the Compose baseline against your production checklist. Volumes, authentication, TLS, pg_cron database name, model provider, queue admin key. SELF_HOST.md is the checklist; the Compose file is not the answer key.
  6. Pin tags, and record the ones you pin. With 810 merges since the last Release, the only reproducible unit is a tag plus the image digest you built from it.
  7. Read the licence with your lawyer, not with a blog. The AGPL analysis above is a summary of the licence’s intent, not advice about your deployment.

FAQ

Is Firecrawl really open source if Alexandria is cloud-only?

The server is AGPL-3.0 and complete enough to scrape, crawl, map, batch-scrape and parse. Alexandria is a separate hosted dataset, and the README states it is not in the self-hosted server. That is open core with the boundary drawn at data, not code — which is a legitimate model, but the 550+ providers in the repo description are not something you can run yourself.

Does Firecrawl Local work without an API key?

Yes for scrape, map, crawl and batch scrape; the README says “local routes need no API key”. Search, blocked-page fallback and Alexandria go to the cloud, where keyless calls are rate limited by an amount the docs do not state.

Can I use Firecrawl Local in production?

You can run it in production; the question is whether its failure modes fit. Jobs live in memory and expire after an hour, json and summary formats are skipped, browser actions are ignored, and v0/v1 routes are not served. For a single-user tool or an agent’s scrape tool it is a good fit. For a queue that must survive a restart, it is the wrong layer.

Why are the SDK versions so far apart?

Because each SDK is versioned independently in the monorepo. Python and JS lead at 4.x, Rust and Elixir at 2.x, and the rest at 1.x. Feature coverage follows the same order: the Python client exposes 77 public methods, JS 71, Go 50.

Why does the release page say v2.11.0 when the tags say v2.11.810?

Because GitHub Releases stopped being cut in June while tag creation continued on every merge. The tag is the artifact; the Release is documentation that has not kept up.

What does self-hosting actually cost in effort?

SELF_HOST.md lists what you own: “security, availability, capacity, upgrades, data retention, and compliance”. Concretely, the checked-in stack has no persistent volumes, no authentication and no model provider, so a production deployment starts by adding three things the file deliberately leaves out.

The bottom line

Firecrawl is a serious piece of infrastructure that has outgrown the shape of its own repository page. The 206,201 stars describe a scraper API. The repository now ships a pre-1.0 local binary, a self-hosted server missing its scraping engine and its data library, and nine SDKs on six version lines. None of those is dishonest; the README and SELF_HOST.md say most of it out loud. What is missing is a single place where the three products’ capabilities are compared — which is why the count that matters is not 206,201 but 6 of 66, and the sentence to remember is the one in serve.rs: “This engine has no data providers of its own, so the request goes to Firecrawl cloud as it came.”

If you want the same kind of boundary reading applied to other projects, the AWS emulator fidelity ledger and the Univer open-source boundary audit use the same method: find the claim, find the code, and count.