Skip to main content
Glama
Firecrawl MCP Multiple Keys

Firecrawl MCP Multiple Keys

by AdvaitR7

Firecrawl MCP Multiple Keys

A Firecrawl MCP server with built-in support for multiple API keys. It exposes Firecrawl's web search, scraping, crawling, extraction, browser interaction, monitoring, and research tools to OpenCode and other MCP clients.

This fork is useful when you want one local Firecrawl MCP server that rotates across a pool of API keys instead of configuring several separate MCP server entries.

Highlights

  • Local stdio MCP server by default

  • Optional Streamable HTTP transport for hosted or local HTTP usage

  • Multi-key rotation with FIRECRAWL_API_KEYS

  • Single-key fallback with FIRECRAWL_API_KEY

  • Process-local round-robin key selection

  • Retry/failover across pooled keys for retryable Firecrawl errors where safe

  • Firecrawl cloud and self-hosted API support

  • TypeScript source bundled with tsup

Related MCP server: WebSearch

Requirements

  • Node.js 22 or newer

  • pnpm

  • One or more Firecrawl API keys

  • OpenCode or another MCP-compatible client

Install

git clone https://github.com/AdvaitR7/firecrawl-mcp-multiple-keys.git
cd firecrawl-mcp-multiple-keys
pnpm install
pnpm run build

The build creates dist/index.js. MCP clients should run that file with Node.

Configure API Keys

For multiple keys, set FIRECRAWL_API_KEYS as a comma-separated or whitespace-separated list:

FIRECRAWL_API_KEYS=firecrawl_key_1,firecrawl_key_2

For a single key, set FIRECRAWL_API_KEY:

FIRECRAWL_API_KEY=firecrawl_key_1

FIRECRAWL_API_KEYS takes precedence over FIRECRAWL_API_KEY unless FIRECRAWL_OAUTH_TOKEN is set.

Key Rotation Behavior

At startup, the server loads FIRECRAWL_API_KEYS into a process-local key pool. Each request that uses the pool starts with the next key in sequence.

request 1 -> key 1
request 2 -> key 2
request 3 -> key 1
request 4 -> key 2

For retryable failures such as 429, 5xx, timeout, or network errors, supported read-style operations can try remaining keys in the current cycle. Mutating operations are more conservative to avoid duplicate jobs.

Header credentials and FIRECRAWL_OAUTH_TOKEN bypass the environment key pool.

OpenCode Setup

Build the project first:

pnpm install
pnpm run build

Add a local MCP entry to your OpenCode config. Use an absolute path to dist/index.js.

Multi-key configuration:

{
  "mcp": {
    "firecrawl": {
      "type": "local",
      "command": ["node", "/absolute/path/to/firecrawl-mcp-multiple-keys/dist/index.js"],
      "enabled": true,
      "timeout": 30000,
      "environment": {
        "FIRECRAWL_API_KEYS": "firecrawl_key_1,firecrawl_key_2"
      }
    }
  }
}

Single-key configuration:

{
  "mcp": {
    "firecrawl": {
      "type": "local",
      "command": ["node", "/absolute/path/to/firecrawl-mcp-multiple-keys/dist/index.js"],
      "enabled": true,
      "timeout": 30000,
      "environment": {
        "FIRECRAWL_API_KEY": "firecrawl_key_1"
      }
    }
  }
}

Restart OpenCode after changing MCP configuration.

Environment Variables

Variable

Required

Description

FIRECRAWL_API_KEYS

No

Comma- or whitespace-separated API keys for round-robin rotation

FIRECRAWL_API_KEY

No

Single Firecrawl API key fallback

FIRECRAWL_OAUTH_TOKEN

No

Static Firecrawl OAuth access token for stdio usage

FIRECRAWL_API_URL

No

Custom Firecrawl API URL for self-hosted instances

HTTP_STREAMABLE_SERVER

No

Set to true to use Streamable HTTP transport

SSE_LOCAL

No

Set to true to use local HTTP stream behavior

CLOUD_SERVICE

No

Set to true for hosted cloud-service behavior

PORT

No

HTTP transport port, default 3000

HOST

No

HTTP transport host, default localhost outside cloud mode

Transport Modes

By default, the server starts on stdio:

FIRECRAWL_API_KEYS=firecrawl_key_1,firecrawl_key_2 node dist/index.js

For local Streamable HTTP transport:

HTTP_STREAMABLE_SERVER=true FIRECRAWL_API_KEY=firecrawl_key_1 node dist/index.js

Direct terminal execution of the stdio server will wait for MCP protocol input. For normal usage, run it through OpenCode or another MCP client.

Tools

Core Firecrawl Tools

Tool

Description

firecrawl_scrape

Scrape a single URL with markdown, JSON, HTML, screenshots, or other formats

firecrawl_map

Discover URLs on a website

firecrawl_search

Search the web, news, images, GitHub, research, or PDFs

firecrawl_search_feedback

Send feedback for a previous Firecrawl search result

firecrawl_feedback

Send generic endpoint feedback for scrape, parse, map, or search jobs

firecrawl_crawl

Crawl multiple pages from a site or section

firecrawl_check_crawl_status

Check an existing crawl job status

firecrawl_extract

Extract structured data from one or more URLs

firecrawl_agent

Start an autonomous web research agent job

firecrawl_agent_status

Poll an agent job until completion

firecrawl_interact

Interact with a web page in a browser session

firecrawl_interact_stop

Stop an interaction session

firecrawl_parse

Parse uploaded or local documents, including PDFs

Monitor Tools

Tool

Description

firecrawl_monitor_create

Create a recurring monitor for pages or searches

firecrawl_monitor_list

List monitors

firecrawl_monitor_get

Get one monitor by ID

firecrawl_monitor_update

Update monitor settings

firecrawl_monitor_delete

Delete a monitor

firecrawl_monitor_run

Trigger a monitor check immediately

firecrawl_monitor_checks

List historical monitor checks

firecrawl_monitor_check

Inspect one monitor check and its page diffs

Research Tools

Tool

Description

firecrawl_research_search_papers

Search research papers by topic

firecrawl_research_inspect_paper

Fetch metadata for one paper

firecrawl_research_related_papers

Expand from seed papers through citation graph similarity

firecrawl_research_read_paper

Read relevant full-text passages for one paper

firecrawl_research_search_github

Search GitHub issues, pull requests, and readmes

Development

Install dependencies:

pnpm install

Build:

pnpm run build

Test:

pnpm test

Lint:

pnpm run lint

Format:

pnpm run format

Run the compiled stdio server:

FIRECRAWL_API_KEYS=firecrawl_key_1,firecrawl_key_2 pnpm start

Security

Never put real Firecrawl API keys in source files, README examples, screenshots, issues, or commits. Keep keys in your MCP client environment config, shell environment, or a local .env file that is not committed.

If a key is exposed, revoke it in Firecrawl and create a replacement key.

License

MIT

Available Tools

26 tools
firecrawl_agentA

Autonomous web research agent. This is a separate AI agent layer that independently browses the internet, searches for information, navigates through pages, and extracts structured data based on your query. You describe what you need, and the agent figures out where to find it.

How it works: The agent performs web searches, follows links, reads pages, and gathers data autonomously. This runs asynchronously - it returns a job ID immediately, and you poll firecrawl_agent_status to check when complete and retrieve results.

IMPORTANT - Async workflow with patient polling:

  1. Call firecrawl_agent with your prompt/schema → returns job ID immediately

  2. Poll firecrawl_agent_status with the job ID to check progress

  3. Keep polling for at least 2-3 minutes - agent research typically takes 1-5 minutes for complex queries

  4. Poll every 15-30 seconds until status is "completed" or "failed"

  5. Do NOT give up after just a few polling attempts - the agent needs time to research

Expected wait times:

  • Simple queries with provided URLs: 30 seconds - 1 minute

  • Complex research across multiple sites: 2-5 minutes

  • Deep research tasks: 5+ minutes

Best for: Complex research tasks where you don't know the exact URLs; multi-source data gathering; finding information scattered across the web; extracting data from JavaScript-heavy SPAs that fail with regular scrape. Not recommended for:

  • Single-page extraction when you have a URL (use firecrawl_scrape, faster and cheaper)

  • Web search (use firecrawl_search first)

  • Interactive page tasks like clicking, filling forms, login, or navigating JS-heavy SPAs (use firecrawl_scrape + firecrawl_interact)

  • Extracting specific data from a known page (use firecrawl_scrape with JSON format)

Arguments:

  • prompt: Natural language description of the data you want (required, max 10,000 characters)

  • urls: Optional array of URLs to focus the agent on specific pages

  • schema: Optional JSON schema for structured output

Prompt Example: "Find the founders of Firecrawl and their backgrounds" Usage Example (start agent, then poll patiently for results):

{
  "name": "firecrawl_agent",
  "arguments": {
    "prompt": "Find the top 5 AI startups founded in 2024 and their funding amounts",
    "schema": {
      "type": "object",
      "properties": {
        "startups": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": { "type": "string" },
              "funding": { "type": "string" },
              "founded": { "type": "string" }
            }
          }
        }
      }
    }
  }
}

Then poll with firecrawl_agent_status every 15-30 seconds for at least 2-3 minutes.

Usage Example (with URLs - agent focuses on specific pages):

{
  "name": "firecrawl_agent",
  "arguments": {
    "urls": ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
    "prompt": "Compare the features and pricing information from these pages"
  }
}

Returns: Job ID for status checking. Use firecrawl_agent_status to poll for results.

Inputs: prompt (required), urls, schema.

firecrawl_agent_statusA
Read-only

Check the status of an agent job and retrieve results when complete. Use this to poll for results after starting an agent with firecrawl_agent.

IMPORTANT - Be patient with polling:

  • Poll every 15-30 seconds

  • Keep polling for at least 2-3 minutes before considering the request failed

  • Complex research can take 5+ minutes - do not give up early

  • Only stop polling when status is "completed" or "failed"

Usage Example:

{
  "name": "firecrawl_agent_status",
  "arguments": {
    "id": "550e8400-e29b-41d4-a716-446655440000"
  }
}

Possible statuses:

  • processing: Agent is still researching - keep polling, do not give up

  • completed: Research finished - response includes the extracted data

  • failed: An error occurred (only stop polling on this status)

Returns: Status, progress, and results (if completed) of the agent job.

Inputs: id (required).

firecrawl_check_crawl_statusB
Read-only

Check the status of a crawl job.

Usage Example:

{
  "name": "firecrawl_check_crawl_status",
  "arguments": {
    "id": "550e8400-e29b-41d4-a716-446655440000"
  }
}

Returns: Status and progress of the crawl job, including results if available.

Inputs: id (required).

firecrawl_crawlA

Starts a crawl job on a website, polls until it reaches a terminal state, and returns the final crawl status/data.

Best for: Extracting content from multiple related pages, when you need comprehensive coverage. Not recommended for: Extracting content from a single page (use scrape); when token limits are a concern (use map + scrape for tighter control); when you need fast results (crawling can be slow). Warning: Crawl responses can be very large and may exceed token limits. Limit the crawl depth and number of pages, or use map + scrape for tighter control. Common mistakes: Setting limit or maxDiscoveryDepth too high (causes token overflow) or too low (causes missing pages); using crawl for a single page (use scrape instead). Using a /* wildcard is not recommended. Prompt Example: "Get all blog posts from the first two levels of example.com/blog." Usage Example:

{
  "name": "firecrawl_crawl",
  "arguments": {
    "url": "https://example.com/blog/*",
    "maxDiscoveryDepth": 5,
    "limit": 20,
    "allowExternalLinks": false,
    "deduplicateSimilarURLs": true,
    "sitemap": "include"
  }
}

Returns: Final crawl status and data after internal polling, including the crawl id. Use firecrawl_check_crawl_status only when you need to re-check an existing crawl ID later.

Inputs: url (required), delay, limit, prompt, +13 more.

firecrawl_extractA
Read-only

Extract structured information from web pages using LLM capabilities. Supports both cloud AI and self-hosted LLM extraction.

Best for: Extracting specific structured data like prices, names, details from web pages. Not recommended for: When you need the full content of a page (use scrape); when you're not looking for specific structured data. Arguments:

  • urls: Array of URLs to extract information from

  • prompt: Custom prompt for the LLM extraction

  • schema: JSON schema for structured data extraction

  • allowExternalLinks: Allow extraction from external links

  • enableWebSearch: Enable web search for additional context

  • includeSubdomains: Include subdomains in extraction Prompt Example: "Extract the product name, price, and description from these product pages." Usage Example:

{
  "name": "firecrawl_extract",
  "arguments": {
    "urls": ["https://example.com/page1", "https://example.com/page2"],
    "prompt": "Extract product information including name, price, and description",
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "price": { "type": "number" },
        "description": { "type": "string" }
      },
      "required": ["name", "price"]
    },
    "allowExternalLinks": false,
    "enableWebSearch": false,
    "includeSubdomains": false
  }
}

Returns: Extracted structured data as defined by your schema.

Inputs: urls (required), prompt, schema, enableWebSearch, +2 more.

firecrawl_feedbackA

Send structured feedback for a completed Firecrawl v2 job. Use this for endpoint-level feedback on scrape, parse, map, or search jobs when the job result was useful, partially useful, or failed to meet expectations.

For search-result quality specifically, prefer firecrawl_search_feedback when available because it has search-focused guidance. This generic tool posts to /v2/feedback and accepts endpoint-wide signals:

  • endpoint — one of search, scrape, parse, or map.

  • jobId — the id returned by that endpoint.

  • rating — overall result quality: good, partial, or bad.

  • issues — stable lowercase issue codes such as missing_markdown, bad_pdf_parse, or wrong_links.

  • tags — optional lowercase tags for grouping feedback.

  • note — short human-readable context. Do not include huge page contents or raw scrape results.

  • url, pageNumbers, and metadata — small contextual fields that identify what the feedback refers to.

Do not store multi-MB outputs in feedback. Use concise notes, issue codes, URLs, and page numbers.

Returns: { success, feedbackId, creditsRefunded, creditsRefundedToday?, dailyRefundCap?, dailyCapReached?, alreadySubmitted?, warning? } JSON.

Inputs: jobId (required), rating (required), endpoint (required), url, +8 more.

firecrawl_interactA

Interact with a page in a live browser session: click buttons, fill forms, extract dynamic content, or navigate deeper.

Best for: Multi-step workflows on a single page — searching a site, clicking through results, filling forms, extracting data that requires interaction. Two ways to target a page:

  • Pass a url to interact directly. The session is opened for you in one call (use this for a fresh page).

  • Pass a scrapeId from a previous firecrawl_scrape to reuse that already-loaded page (cheaper when you just scraped it).

Arguments:

  • url: Page to interact with; opens a session for you (use this OR scrapeId)

  • scrapeId: Scrape job ID from a previous scrape, found in its metadata (use this OR url)

  • prompt: Natural language instruction describing the action to take (use this OR code)

  • code: Code to execute in the browser session (use this OR prompt)

  • language: "bash", "python", or "node" (optional, defaults to "node", only used with code)

  • timeout: Interact execution timeout in seconds, 1-300 (optional, defaults to 30)

  • scrapeOptions: Optional scrape controls used only with url mode, such as waitFor, maxAge, proxy, or zeroDataRetention

Usage Example (prompt, direct via url):

{
  "name": "firecrawl_interact",
  "arguments": {
    "url": "https://example.com/products",
    "prompt": "Click on the first product and tell me its price"
  }
}

Usage Example (code):

{
  "name": "firecrawl_interact",
  "arguments": {
    "scrapeId": "scrape-id-from-previous-scrape",
    "code": "agent-browser click @e5",
    "language": "bash"
  }
}

Returns: Execution result including output, stdout, stderr, exit code, and live view URLs.

Inputs: url, code, prompt, timeout, +3 more.

firecrawl_interact_stopA
Destructive

Stop an interact session for a scraped page. Call this when you are done interacting to free resources.

Usage Example:

{
  "name": "firecrawl_interact_stop",
  "arguments": {
    "scrapeId": "scrape-id-here"
  }
}

Returns: Success confirmation.

Inputs: scrapeId (required).

firecrawl_mapA
Read-only

Map a website to discover all indexed URLs on the site.

Best for: Discovering URLs on a website before deciding what to scrape; finding specific sections or pages within a large site; locating the correct page when scrape returns empty or incomplete results. Not recommended for: When you already know which specific URL you need (use scrape); when you need the content of the pages (use scrape after mapping). Common mistakes: Using crawl to discover URLs instead of map; jumping straight to firecrawl_agent when scrape fails instead of using map first to find the right page.

IMPORTANT - Use map before agent: If firecrawl_scrape returns empty, minimal, or irrelevant content, use firecrawl_map with the search parameter to find the specific page URL containing your target content. This is faster and cheaper than using firecrawl_agent. Only use the agent as a last resort after map+scrape fails.

Prompt Example: "Find the webhook documentation page on this API docs site." Usage Example (discover all URLs):

{
  "name": "firecrawl_map",
  "arguments": {
    "url": "https://example.com"
  }
}

Usage Example (search for specific content - RECOMMENDED when scrape fails):

{
  "name": "firecrawl_map",
  "arguments": {
    "url": "https://docs.example.com/api",
    "search": "webhook events"
  }
}

Returns: Array of URLs found on the site, filtered by search query if provided.

Inputs: url (required), limit, search, sitemap, +2 more.

firecrawl_monitor_checkA
Read-only

Get a single check with page-level diff results. Filter pageStatus to surface only the pages that changed (or were new, removed, etc.).

Each entry in data.pages[] has url, status (same | new | changed | removed | error), optional judgment when goal-based judging ran, and — when changed — a diff and possibly a snapshot. The shape of diff depends on the monitor's formats configuration:

  • Markdown mode (default). diff.text is the unified markdown diff; diff.json is a parse-diff AST ({ files: [...] }). No snapshot.

  • JSON mode (changeTracking with modes: ["json"]). diff.json is a per-field map keyed by JSON path into the extraction, e.g. plans[0].price, with each value being { previous, current }. snapshot.json is the full current extraction. No diff.text.

  • Mixed mode (modes: ["json", "git-diff"]). Both diff.text (markdown sidecar) AND diff.json (per-field map) are present, plus snapshot.json.

Example JSON-mode response pages[] entry:

{
  "url": "https://example.com/pricing",
  "status": "changed",
  "diff": {
    "json": {
      "plans[0].price":       { "previous": "$19/mo",        "current": "$24/mo" },
      "plans[1].features[2]": { "previous": "10 GB storage", "current": "25 GB storage" }
    }
  },
  "snapshot": { "json": { "plans": [/* current full extraction matching the monitor's schema */] } },
  "judgment": {
    "meaningful": true,
    "confidence": "high",
    "reason": "The pricing changed, which matches the monitor goal.",
    "meaningfulChanges": [
      {
        "type": "changed",
        "before": "$19/mo",
        "after": "$24/mo",
        "reason": "The tracked plan price changed."
      }
    ]
  }
}

When summarizing a check for the user, prefer diff.json paths (e.g. "plans[0].price changed from $19/mo to $24/mo") over re-printing the markdown diff — it's more concise and grounded in the schema fields they asked for.

When judgment is present, use it to decide what to surface. judgment.meaningful: false means the change was classified as noise for the monitor's goal. When judgment.meaningfulChanges is present, prefer those goal-relevant changes over raw diff hunks; each item includes type, before, after, and reason.

The endpoint paginates via a top-level next URL; this tool returns one page at a time. Increase limit (max 100) to fetch fewer pages.

Usage Example:

{
  "name": "firecrawl_monitor_check",
  "arguments": {
    "id": "mon_abc123",
    "checkId": "chk_xyz",
    "pageStatus": "changed"
  }
}

Inputs: id (required), checkId (required), skip, limit, +1 more.

firecrawl_monitor_checksA
Read-only

List historical checks for a monitor.

Usage Example:

{ "name": "firecrawl_monitor_checks", "arguments": { "id": "mon_abc123", "limit": 10, "status": "completed" } }

Inputs: id (required), limit, offset, status.

firecrawl_monitor_createA

Create a Firecrawl monitor — a recurring scrape, crawl, or search that diffs each result against the last retained snapshot.

Prefer the simple path: pass page or pages plus goal to monitor specific URLs, OR pass queries plus goal to monitor web search results for new/changed hits. The tool will create the monitor with a 30-minute schedule and meaningful-change judging enabled by the API. Use body only for advanced requests such as crawl targets, JSON change tracking, custom retention, or manual judgeEnabled control.

Meaningful-change judge: set goal to a plain-language description of what the user actually cares about. judgeEnabled defaults to true when goal is set, so providing goal is enough. Page webhooks expose isMeaningful and judgment on monitor.page events.

Simple fields:

  • page: one page URL to monitor.

  • pages: multiple page URLs to monitor.

  • queries: one or more search queries (1-12) to monitor instead of fixed URLs. Each check runs the searches and diffs the result set, so you get alerted when new or changed results appear. Mutually exclusive with page/pages in the simple path.

  • searchWindow: optional recency window for search targets — one of 5m, 15m, 1h, 6h, 24h, 7d (default 24h).

  • maxResults: optional max results per search, 1-50 (default 10).

  • includeDomains / excludeDomains: optional domain allow/deny lists for search targets.

  • goal: plain-English instruction for what changes matter. Required for the simple path (and always required when queries are set — web monitors must have a goal).

  • scheduleText: optional natural-language schedule, default every 30 minutes.

  • email: optional email recipient for summaries.

  • webhookUrl: optional webhook URL. Configures monitor.page and monitor.check.completed.

Search-mode example:

{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "queries": ["new LLM release", "frontier model launch"],
    "goal": "Notify me about major new LLM model releases.",
    "searchWindow": "24h",
    "maxResults": 10
  }
}

Goal guidance:

  • Expand the user's one-line monitoring intent into a concise 2-3 sentence monitor goal.

  • State what should trigger an alert, restate any scope the user gave, and include intent-specific exclusions only when obvious from the user's request.

  • Generic noise such as whitespace, formatting-only changes, request IDs, tracking params, generic metadata, and unrelated page chrome is already handled by the judge; do not repeat it in every goal.

  • If the user is vague, keep the goal broad rather than guessing exclusions. If the user asks for broad monitoring or "any change", preserve that and do not add exclusions that hide changes.

  • If the user says they do not care about something, include that explicitly. It is okay to ask whether they want to ignore specific noise when it is likely to matter.

  • Do not invent page-specific sections, thresholds, entities, or business rules unless the user mentioned them.

Query guidance (web monitors): queries control recall (what search retrieves) and goal controls precision (which results alert) — tune both.

  • Write keywords, not sentences: OpenAI new model release, not tell me when OpenAI releases a new model.

  • Quote multi-word entities ("Llama 4"); group synonyms with OR (launch OR release OR announcement).

  • Keep each query tight (~2-6 terms). One broad query usually beats several narrow ones — extra queries split the maxResults budget. Use one query per distinct entity; do not emit one per facet of a single subject.

  • Keep site: operators out of queries — use includeDomains / excludeDomains.

  • A healthy web monitor mostly returns new: 0 and alerts only on genuinely new, on-goal results. Many ignored results ⇒ queries too broad (tighten them); nothing for long stretches ⇒ queries too narrow or window too tight (broaden); dismissed alerts ⇒ goal too broad (add an intent-specific Ignore). Aim for high precision with enough recall.

Full body requests require: name, schedule (with cron or text), and targets (one or more { type: 'scrape', urls: [...] }, { type: 'crawl', url: '...' }, or { type: 'search', queries: [...], searchWindow?, maxResults?, includeDomains?, excludeDomains? }). Optional: goal (required when any search target is present), judgeEnabled, webhook, notification, retentionDays.

Markdown-mode (default): Each check produces a unified text diff of the page's markdown. No extra configuration needed.

{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "page": "https://example.com/blog",
    "goal": "Alert when a new blog post is published or an existing headline changes.",
    "email": "alerts@example.com"
  }
}

Multiple pages:

{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "pages": ["https://example.com/pricing", "https://example.com/changelog"],
    "goal": "Alert when pricing, packaging, or launch messaging changes.",
    "webhookUrl": "https://example.com/webhooks/firecrawl"
  }
}

JSON-mode change tracking: To detect changes in specific structured fields (price, headline, in-stock flag, list items) instead of the whole page, add a changeTracking format with modes: ["json"] and a JSON schema to the target's scrapeOptions.formats. The check response will then carry a per-field diff (keyed by JSON path, e.g. plans[0].price) and a snapshot.json with the full current extraction. See firecrawl_monitor_check for the response shape.

{
  "name": "firecrawl_monitor_create",
  "arguments": {
    "body": {
      "name": "Pricing watch",
      "schedule": { "text": "hourly", "timezone": "UTC" },
      "goal": "Alert when a pricing tier, price, billing period, limit, or headline feature changes. Ignore unrelated marketing copy unless it changes the pricing offer.",
      "targets": [{
        "type": "scrape",
        "urls": ["https://example.com/pricing"],
        "scrapeOptions": {
          "formats": [{
            "type": "changeTracking",
            "modes": ["json"],
            "prompt": "Extract pricing tiers and headline features for each plan.",
            "schema": {
              "type": "object",
              "properties": {
                "plans": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "name":     { "type": "string" },
                      "price":    { "type": "string" },
                      "features": { "type": "array", "items": { "type": "string" } }
                    }
                  }
                }
              }
            }
          }]
        }
      }]
    }
  }
}

Mixed mode (JSON + git-diff): Use modes: ["json", "git-diff"] to get both per-field diffs and a markdown sidecar. The page is marked changed whenever either surface changed.

Inputs: body, goal, name, page, +11 more.

firecrawl_monitor_deleteA
Destructive

Permanently delete a monitor and stop its schedule. This cannot be undone.

Usage Example:

{ "name": "firecrawl_monitor_delete", "arguments": { "id": "mon_abc123" } }

Inputs: id (required).

firecrawl_monitor_getA
Read-only

Get a single monitor by ID.

Usage Example:

{ "name": "firecrawl_monitor_get", "arguments": { "id": "mon_abc123" } }

Inputs: id (required).

firecrawl_monitor_listC
Read-only

List all Firecrawl monitors for the authenticated account.

Usage Example:

{ "name": "firecrawl_monitor_list", "arguments": { "limit": 20 } }

Inputs: limit, offset.

firecrawl_monitor_runB

Trigger a monitor check immediately, outside its normal schedule. Returns the queued check.

Usage Example:

{ "name": "firecrawl_monitor_run", "arguments": { "id": "mon_abc123" } }

Inputs: id (required).

firecrawl_monitor_updateA
Destructive

Update a monitor. Pass any subset of fields to patch: name, status ("active" | "paused"), schedule, targets, goal, judgeEnabled, webhook, notification, retentionDays.

Usage Example:

{
  "name": "firecrawl_monitor_update",
  "arguments": {
    "id": "mon_abc123",
    "body": { "status": "paused" }
  }
}

Inputs: id (required), body (required).

firecrawl_parseA
Read-only

Parse a file using Firecrawl's /v2/parse endpoint.

In local/non-cloud MCP mode, this tool reads filePath from the MCP server filesystem and posts multipart data to the configured self-hosted FIRECRAWL_API_URL, preserving the existing direct-read behavior.

In hosted CLOUD_SERVICE mode, this tool is a two-call flow because hosted MCP cannot read your local filesystem:

  1. Call with filePath, contentType, parse options, and optional declaredSizeBytes. The hosted server mints a short-lived upload URL and returns a safe local curl PUT command plus nextToolCall.

  2. Run the returned curl command locally, then call firecrawl_parse again with uploadRef and the desired parse options. The hosted server calls /v2/parse server-side with your session credential.

Best for: Extracting content from a local document (PDF, Word, Excel, HTML, etc.); pulling structured data out of a file with JSON format; converting binary documents into markdown for downstream reasoning. Not recommended for: Remote URLs (use firecrawl_scrape); multiple files at once (call parse multiple times); documents that require interactive actions, screenshots, or change tracking — those aren't supported by the parse endpoint. Common mistakes: In hosted mode, do not pass both filePath and uploadRef. Phase 1 uses filePath only to generate upload instructions; phase 2 uses uploadRef only to parse server-side.

Supported file types: .html, .htm, .xhtml, .pdf, .docx, .doc, .odt, .rtf, .xlsx, .xls Unsupported options: actions, screenshot/branding/changeTracking formats, waitFor > 0, location, mobile, proxy values other than "auto" or "basic". Privacy: Set redactPII: true to return content with personally identifiable information redacted.

CRITICAL - Format Selection (same rules as firecrawl_scrape): When the user asks for SPECIFIC data points from a document, you MUST use JSON format with a schema. Only use markdown when the user needs the ENTIRE document content.

Handling PDFs: Add "parsers": ["pdf"] (optionally with pdfOptions.maxPages) when parsing a PDF so the PDF engine is invoked explicitly. For very long documents, cap maxPages to keep the response within token limits.

Hosted phase 1 example:

{
  "name": "firecrawl_parse",
  "arguments": {
    "filePath": "/absolute/path/to/document.pdf",
    "contentType": "application/pdf",
    "formats": ["markdown"],
    "parsers": ["pdf"],
    "zeroDataRetention": true
  }
}

Hosted phase 2 example:

{
  "name": "firecrawl_parse",
  "arguments": {
    "uploadRef": "upload-ref-from-phase-1",
    "formats": ["markdown"],
    "parsers": ["pdf"],
    "zeroDataRetention": true
  }
}

Returns: Phase 1 hosted upload instructions or a parsed document with markdown, html, links, summary, json, or query results depending on the requested formats.

Inputs: filePath (required), proxy, maxAge, formats, +13 more.

firecrawl_research_inspect_paperA
Read-only

Fetch canonical metadata for one paper by primaryId or canonical paperId. Use this after search/related results when you need the full title, abstract, authors, categories, source ids, and dates rendered as markdown.

Inputs: paperId (required).

firecrawl_research_read_paperA
Read-only

Read the most relevant in-body (full-text) passages of ONE specific paper for a question. Use this to VERIFY whether a candidate actually satisfies a constraint before you include or reject it (e.g. 'does this paper actually use technique X / report a score on benchmark Y'). Returns the best-matching passages, or a notice if the paper's full text is unavailable.

Inputs: paperId (required), question (required), k.

firecrawl_research_search_githubA
Read-only

Search GitHub issue/PR history and repository readmes. Returns ranked matches with repo, url, a short snippet, and (when available) the full matched content in markdown.

Inputs: query (required), k.

firecrawl_research_search_papersA
Read-only

Primary entry point for finding research papers by topic across AI/ML, computer science, math, physics, biomedical, life sciences, and clinical literature. Semantic (HyDE) search over indexed paper metadata and abstracts; returns ranked papers with paper id, title, authors, and abstract. The query should be a natural-language research topic or question. Run SEVERAL distinct framings of the question (sibling domains, rival methods, dataset or benchmark names, conditions, populations, interventions, or outcomes) rather than one query — recall improves markedly with diverse framings.

Inputs: query (required), k, to, from, +2 more.

firecrawl_scrapeA

Scrape content from a single URL with advanced options. This is the most powerful, fastest and most reliable scraper tool, if available you should always default to using this tool for any web scraping needs.

Best for: Single page content extraction, when you know exactly which page contains the information. Not recommended for: Multiple pages (call scrape multiple times or use crawl), unknown page location (use search). Common mistakes: Using markdown format when extracting specific data points (use JSON instead). Other Features: Use 'branding' format to extract brand identity (colors, fonts, typography, spacing, UI components) for design analysis or style replication.

CRITICAL - Format Selection (you MUST follow this): When the user asks for SPECIFIC data points, you MUST use JSON format with a schema. Only use markdown when the user needs the ENTIRE page content.

Use JSON format when user asks for:

  • Parameters, fields, or specifications (e.g., "get the header parameters", "what are the required fields")

  • Prices, numbers, or structured data (e.g., "extract the pricing", "get the product details")

  • API details, endpoints, or technical specs (e.g., "find the authentication endpoint")

  • Lists of items or properties (e.g., "list the features", "get all the options")

  • Any specific piece of information from a page

Use markdown format ONLY when:

  • User wants to read/summarize an entire article or blog post

  • User needs to see all content on a page without specific extraction

  • User explicitly asks for the full page content

Handling JavaScript-rendered pages (SPAs): If JSON extraction returns empty, minimal, or just navigation content, the page is likely JavaScript-rendered or the content is on a different URL. Try these steps IN ORDER:

  1. Add waitFor parameter: Set waitFor: 5000 to waitFor: 10000 to allow JavaScript to render before extraction

  2. Try a different URL: If the URL has a hash fragment (#section), try the base URL or look for a direct page URL

  3. Use firecrawl_map to find the correct page: Large documentation sites or SPAs often spread content across multiple URLs. Use firecrawl_map with a search parameter to discover the specific page containing your target content, then scrape that URL directly. Example: If scraping "https://docs.example.com/reference" fails to find webhook parameters, use firecrawl_map with {"url": "https://docs.example.com/reference", "search": "webhook"} to find URLs like "/reference/webhook-events", then scrape that specific page.

  4. Use firecrawl_agent: As a last resort for heavily dynamic pages where map+scrape still fails, use the agent which can autonomously navigate and research

Usage Example (JSON format - REQUIRED for specific data extraction):

{
  "name": "firecrawl_scrape",
  "arguments": {
    "url": "https://example.com/api-docs",
    "formats": ["json"],
    "jsonOptions": {
      "prompt": "Extract the header parameters for the authentication endpoint",
      "schema": {
        "type": "object",
        "properties": {
          "parameters": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": { "type": "string" },
                "type": { "type": "string" },
                "required": { "type": "boolean" },
                "description": { "type": "string" }
              }
            }
          }
        }
      }
    }
  }
}

Prefer markdown format by default. You can read and reason over the full page content directly — no need for an intermediate query step. Use markdown for questions about page content, factual lookups, and any task where you need to understand the page.

Use JSON format when user needs:

  • Structured data with specific fields (extract all products with name, price, description)

  • Data in a specific schema for downstream processing

Use query format only when:

  • The page is extremely long and you need a single targeted answer without processing the full content

  • You want a quick factual answer and don't need to retain the page content

  • Set queryOptions.mode to "directQuote" when you need verbatim page text; otherwise it defaults to "freeform"

Usage Example (markdown format - default for most tasks):

{
  "name": "firecrawl_scrape",
  "arguments": {
    "url": "https://example.com/article",
    "formats": ["markdown"],
    "onlyMainContent": true
  }
}

Usage Example (branding format - extract brand identity):

{
  "name": "firecrawl_scrape",
  "arguments": {
    "url": "https://example.com",
    "formats": ["branding"]
  }
}

Branding format: Extracts comprehensive brand identity (colors, fonts, typography, spacing, logo, UI components) for design analysis or style replication. Performance: Add maxAge parameter for 500% faster scrapes using cached data. Lockdown mode: Set lockdown: true to serve the request only from the existing index/cache without any outbound network request. For air-gapped or compliance-constrained use where the request URL itself is considered sensitive. Errors on cache miss. Billed at 5 credits. Privacy: Set redactPII: true to return content with personally identifiable information redacted. Returns: JSON structured data, markdown, branding profile, or other formats as specified.

Inputs: url (required), proxy, maxAge, mobile, +19 more.

firecrawl_search_feedbackA

Send structured feedback on a previous firecrawl_search result. Call this immediately after a search where you used the results so we can improve search quality and refund 1 credit (search costs 2).

Pass the searchId returned by firecrawl_search (the id field on the response) and tell us:

  • rating — overall result quality: good, partial, or bad.

  • valuableSources — which result URLs were actually useful, and a short reason why.

  • missingContent — the most important field. An ARRAY of specific pieces of content you expected to find but didn't. One entry per missing piece, each with a short topic and an optional longer description. Examples: {"topic":"enterprise pricing","description":"no pricing tier table for the Enterprise plan was returned"}, {"topic":"API rate limits"}, {"topic":"comparison vs competitors"}. Be specific — these aggregate across teams and tell us what to index next. Do not pack multiple topics into one entry.

  • querySuggestions — how the query or response shape could be improved (e.g. "would have liked official docs first", "should boost github.com").

Substantive-feedback requirement (zero-effort feedback is rejected with HTTP 400):

  • good — must include at least one valuableSources entry

  • partial — must include valuableSources or at least one missingContent entry

  • bad — must include at least one missingContent entry or querySuggestions

Time window: Feedback must be submitted within ~2 minutes of the search. Beyond that, the call returns HTTP 409 with feedbackErrorCode: "FEEDBACK_WINDOW_EXPIRED" — do not retry, just move on. Same goes for any 4xx response: do not retry-loop.

Behaviors:

  • Idempotent per searchId. Re-submitting for the same id returns alreadySubmitted: true with creditsRefunded: 0.

  • Refund only applies to billable searches; preview teams are blocked.

  • Failed searches cannot receive feedback (the search itself already returned an error you can act on).

  • Daily refund cap (per team, per UTC day, default 100 credits). Once a team's creditsRefundedToday reaches dailyRefundCap, the response returns dailyCapReached: true with creditsRefunded: 0. The feedback is still recorded for search-quality improvement — only the credit refund is gated. Stop calling this tool for the rest of the UTC day when you see dailyCapReached: true.

When to call: Right after processing a search result. If the result didn't help, send rating bad with a clear missingContent — that is just as valuable as a good rating.

Usage Example (good rating with valuable sources + missing content):

{
  "name": "firecrawl_search_feedback",
  "arguments": {
    "searchId": "0193f6c5-1234-7890-abcd-1234567890ab",
    "rating": "good",
    "valuableSources": [
      { "url": "https://docs.firecrawl.dev/features/search", "reason": "Most up-to-date description of /search." }
    ],
    "missingContent": [
      { "topic": "Pricing for the search endpoint", "description": "No pricing tier table for /search specifically." },
      { "topic": "Rate limits", "description": "Per-team RPS for /search not documented." }
    ],
    "querySuggestions": "Boost docs.firecrawl.dev for queries that mention 'firecrawl'"
  }
}

Usage Example (bad rating, what was missing):

{
  "name": "firecrawl_search_feedback",
  "arguments": {
    "searchId": "0193f6c5-1234-7890-abcd-1234567890ab",
    "rating": "bad",
    "missingContent": [
      { "topic": "Recent benchmarks", "description": "All results were >12 months old." },
      { "topic": "Comparison vs Algolia" }
    ]
  }
}

Returns: { success, feedbackId, creditsRefunded, creditsRefundedToday, dailyRefundCap, dailyCapReached?, alreadySubmitted?, warning? } JSON.

Inputs: rating (required), searchId (required), missingContent, valuableSources, +1 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 26 tools

    Disambiguation4/5

    Tool purposes are mostly distinct, but some overlap exists between scrape/extract/parse and search/agent. Detailed descriptions help differentiate, but agents may occasionally misselect between search and agent for similar queries.

    Naming Consistency5/5

    All tools follow the firecrawl_verb_noun pattern consistently. No mixed casing or irregular naming. The prefix is uniform and the verb+noun structure makes the purpose clear.

    Tool Count3/5

    26 tools is high for a single server. While each tool has a unique role, the research-related tools (5 for papers/GitHub) and monitoring CRUD (7 tools) could be consolidated. The count feels slightly bloated for the core purpose of web scraping.

    Completeness4/5

    The tool surface covers a comprehensive range: scraping, crawling, mapping, search, extraction, monitoring, interaction, and feedback. Minor gaps exist (e.g., no batch operations or site structure analysis), but core workflows are well-supported.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      D
      maintenance
      A server that provides web scraping and intelligent content searching capabilities using the Firecrawl API, enabling AI agents to extract structured data from websites and perform content searches.
      5
      3
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      A Model Context Protocol server that enables web scraping, crawling, and content extraction capabilities through integration with Firecrawl.
      8
      181,410 npm
      2
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      A production-ready Model Context Protocol (MCP) server that integrates with the Firecrawl API to give AI assistants the power to scrape, crawl, and search the web.
      3
      -