Firecrawl MCP Server

The Firecrawl MCP server connects an agent to Firecrawl's web API. It can search the web, scrape a page into clean Markdown or JSON, map and crawl a site, parse PDFs, click through a page in a real browser and watch pages for changes. The server is MIT licensed, but the work runs on Firecrawl's service and costs credits. We checked it on 31 October 2026.

Quick facts

What it does

A plain fetch tool returns raw HTML or a rough text dump. Firecrawl's service renders the page, strips navigation and ads, and gives back Markdown or JSON that fits a schema you write. That matters because an agent pays for every token it reads. A page that comes back as 3,000 words of clean text is cheaper and easier to use than the same page with its menus and scripts.

The README groups the features like this:

• Search the web, optionally with the full content of each result.
• Search special indexes: developer sources (GitHub issues, merged pull requests, READMEs and docs), US government sources, and scientific papers from PubMed, bioRxiv, medRxiv and arXiv.
• Scrape a URL into Markdown or structured JSON.
• Parse PDFs and other documents.
• Crawl a site for many pages, or map it to list its URLs.
• Interact with a page in a real browser: click, type, fill forms.
• Run Agent jobs, which do multi-source research and return structured data.
• Monitor pages and report when the content changes.
• Check credit usage.
• Retry and rate-limit automatically, and run against the cloud or a self-hosted instance.

Our view: this is a bigger surface than most "scrape" servers. Part of it is a plain scraper. Part of it is a research service that happens to speak MCP.

The tools, and when to use each

The README has a decision guide. We have kept its logic and shortened it.

There are also Alexandria tools, which look up and run capabilities from catalogued data providers, and feedback tools. The search feedback tool refunds 1 credit on the first report per search, with a daily cap, per the README.

Scrape: prefer JSON over Markdown

The README makes a point that is worth repeating. When you need a price, a name and a description, ask for JSON with a schema. Use Markdown only when you really need the whole page. A schema keeps the response small and stops the agent's context window from filling up.

{
  "name": "firecrawl_scrape",
  "arguments": {
    "url": "https://example.com/product",
    "formats": [{
      "type": "json",
      "prompt": "Extract the product information",
      "schema": {
        "type": "object",
        "properties": {
          "name": { "type": "string" },
          "price": { "type": "number" }
        },
        "required": ["name", "price"]
      }
    }]
  }
}

You do not write this by hand. You say "get the product details from this URL" and the agent builds the call. It helps to know what is underneath.

Crawl: always set limits

A crawl follows links and bills per page. The README says to bound it with limit, includePaths, excludePaths or maxDiscoveryDepth. Without a limit, an enthusiastic agent can spend a lot of credits on a large site. Map first, pick the sections you need, then scrape or crawl those.

Search: watch the scrape options

Search costs 2 credits per 10 results, per Firecrawl's pricing page. The README warns that scrapeOptions fetches every result's page in the same call and bills each as a scrape. Keep it for the full text of a few results. For most questions, read the excerpts and scrape only the URLs that matter.

Interact: a browser turn at a time

firecrawl_interact opens a page and runs one prompt or code turn to completion. You can pass a url for a fresh page or a scrapeId to continue on one you already scraped, then end the session with firecrawl_interact_stop. The README says this is not a good fit when you need to hold a session open across many of your own steps with your own retry logic. For that, a browser tool such as Playwright MCP gives you step-level control.

What it costs

The MCP server is free. The credits are not. From Firecrawl's pricing page, which shows prices effective 4 September 2026:

How credits are used, from the same page:

• 1 credit per page on a basic scrape or crawl, and 1 credit per Map call.
• Search is 2 credits per 10 results.
• Interact is 2 credits per browser minute.
• On scrape and crawl, the JSON, Question and Highlight formats add 4 credits per page.
• Monitor's deterministic extraction bills a flat 7 credits per page per check.
• A scrape that returns no result is not charged. A page that responds with a 403 or 404 is still returned and costs 1 credit.

Credits are shared across all endpoints. Paid plans can turn on pay-as-you-go, which adds credits in 5 USD steps up to a monthly limit you set.

One planning note. JSON extraction adds 4 credits, so a JSON scrape costs about five times a plain one. That is often still the right call, because the response is smaller, but your budget should use that number.

Install it

Firecrawl documents several routes. The hosted server is the simplest, since there is nothing to run.

Hosted, keyless

https://mcp.firecrawl.dev/v2/mcp

With no key, scrape, search and parse work, rate-limited. crawl, map and agent need a key. The README says to prefer OAuth or an API key whenever you can sign up, because that unlocks the full tool set and higher limits.

Hosted, with an API key

Keep the URL the same and send the key as a header: Authorization: Bearer <FIRECRAWL_API_KEY>. The README is firm that you should never put an API key in the server URL or in an agent chat. Put it in the client's secret or header setting.

Hosted, with an account connection

Use https://mcp.firecrawl.dev/v2/mcp-oauth with your client's account connection flow. The README notes this is an MCP endpoint, not a browser page, and that you should not add a second Firecrawl entry when reconnecting.

Local, with npx

env FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp

Docker

docker run -i --rm -e FIRECRAWL_API_KEY=fc-YOUR_API_KEY ghcr.io/firecrawl/firecrawl-mcp-server:latest

The README says to pin sha-<commit sha> or a digest when you need a fixed image, because latest and v<package version> move.

Install it in each agent

The README documents Cursor, Windsurf, VS Code and Claude Desktop with the stdio entry. Lines for the other agents are our adaptation from each agent's own MCP docs. For how these agents name fields, see MCP clients.

Claude Code

Our adaptation, stdio:

claude mcp add firecrawl -e FIRECRAWL_API_KEY=fc-YOUR_API_KEY -- npx -y firecrawl-mcp

Hosted, with a header, from Claude Code's MCP docs:

claude mcp add --transport http firecrawl https://mcp.firecrawl.dev/v2/mcp \
  --header "Authorization: Bearer fc-YOUR_API_KEY"

Codex

Our adaptation, in ~/.codex/config.toml:

[mcp_servers.firecrawl]
command = "npx"
args = ["-y", "firecrawl-mcp"]

[mcp_servers.firecrawl.env]
FIRECRAWL_API_KEY = "fc-YOUR_API_KEY"

Cursor

The README's entry, in Cursor's MCP settings or .cursor/mcp.json, needs Cursor 0.45.6 or newer:

{
  "mcpServers": {
    "firecrawl-mcp": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": { "FIRECRAWL_API_KEY": "YOUR-API-KEY" }
    }
  }
}

Antigravity

Our adaptation. Add the same stdio entry to ~/.gemini/config/mcp_config.json under the mcpServers key. For the hosted endpoint, Antigravity uses serverUrl for Streamable HTTP, so the URL goes there. Antigravity's MCP docs say a headers object sends custom HTTP headers with serverUrl connections, so an Authorization header is possible. Gemini CLI is now for Code Assist enterprise customers only, so we cover Antigravity here.

OpenCode

Our adaptation, in opencode.json:

{
  "mcp": {
    "firecrawl": {
      "type": "local",
      "command": ["npx", "-y", "firecrawl-mcp"],
      "environment": { "FIRECRAWL_API_KEY": "fc-YOUR_API_KEY" }
    }
  }
}

VS Code

The README gives a .vscode/mcp.json entry that uses a prompted input for the key, so the key never sits in the file:

{
  "inputs": [{ "type": "promptString", "id": "apiKey",
               "description": "Firecrawl API Key", "password": true }],
  "servers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": { "FIRECRAWL_API_KEY": "${input:apiKey}" }
    }
  }
}

Configuration worth knowing

• FIRECRAWL_API_URL points the server at a self-hosted Firecrawl. A key is optional when your instance does not require one.
• FIRECRAWL_OAUTH_TOKEN supplies a static OAuth access token over stdio. Use access tokens (fco_), never refresh tokens (fcr_).
• HTTP_STREAMABLE_SERVER=true serves the tools at http://localhost:3000/mcp instead of stdio.
• FIRECRAWL_MCP_ALLOWED_HOSTS lists extra host names the local HTTP server will answer.
• FIRECRAWL_NO_SEARCH_FEEDBACK=1 and FIRECRAWL_NO_ENDPOINT_FEEDBACK=1 remove the feedback tools and shrink the tool count.

Security notes

1. Your key is a spending limit. Anyone with it spends your credits. Use the prompted-input pattern, a secret manager or a header setting. Do not paste it into a chat.
2. Local HTTP mode checks hosts. In streamable HTTP mode the server answers only localhost, 127.0.0.1 and [::1] by default and returns 403 for other Host or Origin headers. The README says this stops web pages you visit from using the local server through DNS rebinding. Setting FIRECRAWL_MCP_ALLOWED_HOSTS=* turns the check off.
3. Binding to a network address shares your key. If you set HOST=0.0.0.0, every client that reaches the port is served with the server's key. The README says to do this only on a trusted network.
4. Scraped pages are untrusted input. A page can contain text written to steer an agent. Treat what comes back as data, not instructions, and be careful when the same agent also has file or shell access.
5. PII redaction exists. Scrape accepts redactPII: true to return content with personal data redacted, per the README.
6. Use a spending guard. Keep an eye on usage with firecrawl_credit_usage, and set a pay-as-you-go limit if you turn that on. The agent tool also takes a maxCredits cap, which the API defaults to 2,500 when you leave it out.

Respect the sites you scrape. Firecrawl returns what it can reach, and whether you may use it is a matter of that site's terms and the law where you work.

Limits and known issues

• Credits move fast. A crawl, a JSON scrape and a search with page content each draw on one balance. A free tier of 1,000 credits is a trial, not a workflow.
• Tool count. With the full profile there are 27 tools. Some clients limit tool slots. The README says the hosted keyless endpoint exposes only 3 and the search-only endpoint exposes 9.
• Release tags lag the code. The latest GitHub release is v3.2.1 from September 2025, while the repo was pushed in late October 2026. Pin an image digest if you need a fixed build.
• Open issues. The repo showed 183 open issues on 31 October 2026. Search the tracker for rate limits, auth or the tool you rely on before you commit.
• One URL per scrape. The README lists "passing a list of URLs to one scrape call" as a common mistake. Call scrape once per URL.

Alternatives

The MCP servers hub lists more.

Which agents it suits

• Claude Code, Codex, Cursor, OpenCode and VS Code all take the stdio entry as is.
• Antigravity takes the stdio entry too. The hosted route needs a check on header support.
• Agents that answer questions about docs or competitors gain most, since search plus scrape plus JSON covers that loop.
• Agents on a tight tool budget can use the keyless or search-only endpoints to keep the tool list short.

Our take

We did not run Firecrawl for this page. This comes from the README, the pricing page and the repo data.

The strongest case for it is structured extraction. A schema in, clean JSON out, is a better contract than a page of text, and it keeps your context small. The developer search and research tools are a thoughtful extra for coding agents, since they aim at the sources a developer actually needs.

The cost is the catch. A free MCP server that draws on a metered service is cheap to try and easy to overspend. Read the credit table before you let an agent crawl, and set limits on every crawl.

If you only need to read a known page now and then, Fetch MCP is free and simple. If you need search, structure and scale, Firecrawl is a reasonable choice.

A short setup checklist

1. Make a Firecrawl account and note the free tier's 1,000 credits.
2. Start with the hosted keyless endpoint to try scrape and search.
3. Move to an API key in a secret setting when you need crawl, map or agent.
4. Tell your agent to prefer JSON scrapes with a schema.
5. Require a limit on every crawl.
6. Check firecrawl_credit_usage after your first real task.
7. Turn off pay-as-you-go until you know your monthly use.

Frequently asked questions

What does the Firecrawl MCP server do?

It lets an agent search the web, scrape pages into Markdown or JSON, crawl or map sites, parse documents and drive a page in a real browser.

Is the Firecrawl MCP server free?

The server is MIT licensed. The service has a free tier of 1,000 credits a month, and the hosted keyless endpoint offers scrape, search and parse with rate limits.

Do I need an API key?

For the full tool set, yes. A self-hosted Firecrawl may not need one.

Can I run it against my own Firecrawl instance?

Yes. Set FIRECRAWL_API_URL to your instance.

How is it different from a fetch server?

A fetch server downloads a page. Firecrawl renders it, returns clean Markdown or schema-shaped JSON, and adds crawling, search and browser actions at a per-credit cost.