Firecrawl MCP Server vs Resolve
A side-by-side look at the Firecrawl MCP Server and Resolve MCP servers: transport, auth, tools, quality signals, and the config to install either one in Claude, Cursor, Windsurf or VS Code.
Verdict: choose Firecrawl MCP Server for search & data extraction work as a local process; choose Resolve for cryptography as a local process. You can also run both side by side in one mcpServers block.
Which MCP server should you choose?
Choose Firecrawl MCP Server when
- You need dedicated capabilities in the Search & Data Extraction domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: API key required.
- You have the keys it needs:
FIRECRAWL_API_KEY, HTTP_STREAMABLE_SERVER, FIRECRAWL_NO_SEARCH_FEEDBACK, FIRECRAWL_NO_ENDPOINT_FEEDBACK. - You want tools like
firecrawl_scrape, firecrawl_map, firecrawl_search.
Choose Resolve when
- You need dedicated capabilities in the Cryptography domain.
- You prefer a local stdio subprocess transport.
- Its auth model fits you: No auth required.
- You have the keys it needs:
FORESTRIE_BASE_URL, FORESTRIE_RPC_URL. - You want tools like
fetch_scitt_configuration, query_registration, fetch_receipt.
Feature & specification comparison
Rows where the two servers differ are marked.
| Spec | ||
|---|---|---|
| Category | Search & Data Extraction | Cryptography |
| Quality signal | 90/100 · Excellent | 63/100 · Good |
| Install command | Confirmed | Confirmed |
| Transport | Local subprocess (stdio) | Local subprocess (stdio) |
| Auth | API key required | No auth required |
| Pricing | Freemium | Free |
| Required env vars | FIRECRAWL_API_KEYHTTP_STREAMABLE_SERVERFIRECRAWL_NO_SEARCH_FEEDBACKFIRECRAWL_NO_ENDPOINT_FEEDBACK | FORESTRIE_BASE_URLFORESTRIE_RPC_URL |
| Verified owner | Verified | Community listing |
| GitHub stars | 7,642 | 0 |
| Directory activity | 13 views 0 installs 0 upvotes | 1 views 0 installs 0 upvotes |
| Tools | 25 | 8 |
| Full listing | View Firecrawl MCP Server | View Resolve |
Tools & capabilities
Firecrawl MCP Server tools 25
firecrawl_scrapeRetrieve and extract content from one supplied URL through Firecrawl. Use this when the request identifies a page and needs its content or defined fields. It can return markdown, HTML, links, screenshots, branding data, a targeted answer, or JSON matching a supplied schema; JSON is useful when the requested result has defined fields, while markdown preserves readable page content. This tool operates on a known page. For a set of pages use `firecrawl_crawl`, and to discover page URLs use `firecrawl_map` or `firecrawl_search`. Options include JavaScript render delay, cache age, main-content filtering, PII redaction, and lockdown cache-only retrieval. Browser actions may change the live page when interactive actions are enabled. Firecrawl may reuse recently indexed content instead of refetching the page, and the reuse window varies by domain. Set `maxAge: 0` to force a live fetch, or a smaller `maxAge` to bound how stale reused content may be. A successful response does not by itself confirm that the state it describes is still current. Returns the selected content formats and page metadata.firecrawl_mapEnumerate URLs indexed under one website through Firecrawl without fetching each page's content. Use this when the request asks for a site's URL inventory, when several relevant pages must be located, or when the desired page URL is unknown. An optional `search` term narrows the URL list, while sitemap, subdomain, query-parameter, and result-limit options control coverage. Returns matching URLs rather than page bodies. Retrieve one page with `firecrawl_scrape`; collect content across multiple pages with `firecrawl_crawl`.firecrawl_searchSearch web, news, or image sources and return ranked results. Operators include quoted phrases, `-term`, `site:host`, `inurl:term`, `intitle:term`, and `related:host`; the set is non-exhaustive. `includeDomains` and `excludeDomains` are mutually exclusive hostname filters; categories limit results to GitHub, research, PDF, or developer sources. For a programming question, add `categories: ["developer"]`. It searches an index of GitHub issues, merged pull requests, repository READMEs, and curated documentation sites, and returns the hits in `data.developer` beside the web results. `categories: ["research"]` restricts these web results to research-affiliated websites and returns page snippets. The `firecrawl_research_*` tools are a separate surface that searches paper abstracts and full text across biomedical (PubMed, bioRxiv, medRxiv) and arXiv literature. `scrapeOptions` can attach extracted page content; pages fetched this way use a fixed reuse window and ignore `maxAge`, so use `firecrawl_scrape` when a live fetch is required. Returns source-type result groups and usage metadata. Authenticated responses can include an `id` for optional search feedback.firecrawl_crawlStart a multi-page crawl at a website URL, poll it to a terminal state, and return the final status and collected data. Scope can be bounded with include/exclude paths, depth, page limit, subdomain/external-link controls, sitemap handling, delay, and scrape options. Crawl results can be large; use conservative limits when full-site coverage is unnecessary. Webhooks and interactive scrape actions are unavailable in safe mode. Returns the crawl ID, status, and page data.firecrawl_check_crawl_statusRetrieve the current status, progress, and available results for an existing crawl ID. This only reads Firecrawl job state and does not start or modify the crawl.firecrawl_extractDeprecated compatibility entry point. Use firecrawl_scrape once per known URL with formats: ["json"] and jsonOptions containing the prompt and schema. Use firecrawl_search or firecrawl_agent before Scrape when URLs are not known.firecrawl_agentStart an asynchronous web research job from a prompt, optional seed URLs, and an optional JSON schema. Use this for a requested synthesis across multiple sources when the task can wait for asynchronous completion. The agent can search, navigate, read pages, and assemble a structured result. This call returns only a job ID, not the research result. Read the job with `firecrawl_agent_status` until it reaches `completed` or `failed`; research commonly takes several minutes. If the job cannot finish within the task's available time, `firecrawl_search` and `firecrawl_scrape` can gather evidence synchronously.firecrawl_agent_statusRetrieve progress or final results for a `firecrawl_agent` job ID. A `processing` response is non-terminal and does not contain the final research result. Check again after 15–30 seconds until the status is `completed` or `failed`; complex jobs can take several minutes. If the job cannot finish within the task's available time, use `firecrawl_search` and `firecrawl_scrape` to complete the requested output. Returns job status, progress information, and result data when completed.firecrawl_interactOpen or reuse a live browser session to navigate a page, click controls, fill fields, or run browser code. Provide either `url` or `scrapeId`, and either a natural-language `prompt` or executable `code`; code can run as Bash, Python, or Node with a bounded timeout. This acts on the live site, so actions such as form submission can create persistent external side effects. Returns execution output, stdout/stderr, exit status, and session viewing URLs.firecrawl_interact_stopStop the live interact session associated with a `scrapeId` and release its resources. Returns a success confirmation.firecrawl_parseParse one supported document into markdown, HTML, links, summary, targeted answers, or JSON matching a schema. Supported inputs include common HTML, PDF, Word, RTF, OpenDocument, and spreadsheet files; PDF parsing can be bounded with `pdfOptions.maxPages`. Local MCP reads `filePath` from the server filesystem. Hosted MCP uses two calls: first provide `filePath` to receive upload instructions, upload locally, then call again with the returned `uploadRef`; do not send both fields together. Remote web URLs belong in `firecrawl_scrape`. Set `redactPII` to request redaction of personally identifiable information in the returned content. `zeroDataRetention` requires an eligible authenticated account; omit it for anonymous keyless use. Returns upload instructions for hosted phase one or parsed document content for the final call.firecrawl_monitor_createCreate a recurring scrape, crawl, or search monitor that compares each check with its retained predecessor. The simple form accepts `page`/`pages` or `queries` plus a plain-language `goal`; the advanced `body` form controls targets, schedule, change-tracking formats, judging, retention, webhook, and notifications. In the simple form, a `goal` is required. If `queries` contains one or more non-empty values and is supplied with `page`/`pages`, `queries` create the search target and page targets are ignored. A monitor schedules future network checks and can send configured email or webhook notifications. Returns the created monitor.- +13 more on the listing page
Resolve tools 8
fetch_scitt_configurationGET {baseUrl}/.well-known/scitt-configuration: the transparency service's self-description (service id, base URL, supported algorithms), returned as JSON. Provenance: fetched. Supports: none of the four questions; this is what the operator says about itself.query_registrationOne GET of {baseUrl}/logs/{bootstrapLogId}/{logId}/entries/{contentHash}, where contentHash is the hex sha256 of the signed statement bytes. Returns pending (with retryAfterMs when the server said so) or the receipt's URL, which includes the massif height, and the entry id. pending is the operator's answer for any content hash its sequencing index does not hold yet, including one that was never registered: the operator does not distinguish the two, so a retry only helps for a statement you know was submitted. receipt-available is the index's answer, not proof the receipt is written: fetch_receipt is the check, and a 404 there is not_found, never pending. Never polls: call again yourself if you want to. Provenance: fetched. Supports: none of the four questions; this is registration status.fetch_receiptGET a receipt: either by receiptUrl (as returned by query_registration) or by {baseUrl, bootstrapLogId, logId, massifHeight, entryId}. Returns the receipt bytes base64-encoded, the verifier's decoding of them, and receiptLogId: the log the receipt's delegation certificate names, which is the operator's statement like the rest of the receipt. A 404 is the structured problem not_found carrying the operator's own title (for example 'Entry receipt not found (checkpoint missing)' for a wrong massif height); it is never reported as pending, because a receipt URL the operator holds nothing at does not fill in by waiting. Provenance: fetched. Supports: none on its own; a receipt is the operator's claim, so verify it under a trust root you hold (or use verify_fetched_receipt).fetch_genesisGET {baseUrl}/api/forest/{logId}/genesis: the forest's genesis document as CBOR, base64-encoded, with what it carries decoded: the chain binding (univocity contract address, chain id, forest log id) and, for an ES256 forest, the bootstrap public key as bootstrapKeyXy (x‖y hex). Both are read from these bytes, so they stand exactly where the copy stands. For capture: obtain it once, keep it, and pass it as bytes from then on. A copy obtained at check time is not the genesis trust root as intended, and its chain binding and bootstrap key are likewise the operator's claim today; keep the copy from registration, or cross-check them against a source you trust independently. Provenance: fetched. Supports: sealing, as known-log-key with the key this copy carries.fetch_accumulatorRead the log's published accumulator from the univocity contract at your rpcUrl: eth_chainId, then eth_getBlockByNumber latest, then one eth_call logState(logId) at that block. The contract address and chain id come from a genesis you hold ({genesis, rpcUrl, logId}) or are given explicitly ({rpcUrl, univocity, logId, chainId?}); a chain id mismatch is reported as a problem before any call. Optionally pass forReceipt (the receipt bytes with the registered payload and its entryId, or the committed grant bytes with grant true; bytes base64): if later growth has buried that receipt's peak, so the latest state no longer holds it, the tool walks the contract's CheckpointPublished history backwards within the bounds you set in chain.history and returns the newest checkpoint that holds the peak, saying so in provenance.history; running out of range is a structured problem, history_scan_exhausted. Returns the snapshot CBOR the verifier's known-accumulator root consumes, base64-encoded, with size, block number and block hash. Provenance: chain-read. Supports: split-view under known-accumulator, against the chain rather than the operator; sealing and append-authority by inheritance from the contract's publish-time checks, not by a local signature check.fetch_checkpoint_historyRead the log's published checkpoints from the univocity contract's CheckpointPublished events at your rpcUrl, newest first, in windows of history.chunkBlocks (default 10000) walking back from the latest block to history.fromBlock, or for at most history.maxBlocks (default 200000): one eth_getLogs per window, never an unbounded scan. The contract address and chain id come from a genesis you hold or are given explicitly, as for fetch_accumulator. Returns each checkpoint's size, accumulator, block number, block hash and transaction hash, plus the same checkpoint as a known-accumulator snapshot (base64) you can keep and later pass to verify_fetched_receipt as supplied bytes; and scannedFrom, scannedTo and the number of requests made. For capture: the contract keeps only its latest state, and a receipt whose peak later growth has buried verifies only against a checkpoint that still holds that peak, so keep the ones you need. Provenance: chain-read. Supports: as fetch_accumulator, split-view under known-accumulator against the chain rather than the operator; sealing and append-authority by inheritance from the contract's publish-time checks, not by a local signature check.fetch_ks256_attestationFor a receipt whose delegation certificate is signed by a contract KS256 root (a Safe, say): ask the contract whether it accepts that certificate, and return the answer as an attestation @forestrie/mcp-verify can consume offline. Reads the chain at your rpcUrl (this tool does; mcp-verify never does): eth_chainId, eth_getBlockByNumber for your block (default latest), then eth_getCode at the root and one eth_call isValidSignature(digest, signature), where digest and signature come from the receipt's certificate. Both state reads are pinned by the block's hash (EIP-1898, requireCanonical), so the hash in the attestation is the state that was read. Give the receipt, and the root as root (0x 20-byte address) or as a genesis you hold (genesis; it supplies the root when root is absent, which must then be a KS256 bootstrap root, and always supplies the chain the RPC must be on; a chain id mismatch is a problem before any further call). Returns the attestation as canonical CBOR, base64-encoded, with its fields (chain id, root address, digest, signature hash, block number, block hash, magic). Pass it to verify_receipt in mcp-verify as ks256Attestation: it then attests the certificate valid under the contract's signers at block N, which is narrower than an EOA root's offline ecrecover check; anyone with RPC can re-run the call at that block to confirm or disprove it. Refuses, with a structured problem and never an attestation, when there is no contract code at the root (an EOA root verifies by ecrecover and needs none), when the call reverts, or when the return is anything but exactly one 32-byte word, 0x1626ba7e followed by 28 zero bytes (a short return, dirty padding, extra words or an echo of the call's own data are all refused); a malformed chain id, block or hash from the RPC is an rpc_error problem. With root given beside a genesis, root is the contract asked and the genesis supplies only the expected chain (provenance.binding is explicit, chainFrom held-genesis); binding is held-genesis only when the root came from the genesis. Provenance: chain-read. Supports: none of the four questions on its own; the attestation is evidence only once mcp-verify consumes it under a root you hold.verify_fetched_receiptFetch a receipt (as fetch_receipt) and verify it with @forestrie/mcp-verify's core under a trust root you supply as bytes (genesis, keyXy, accumulator, or checkpoints; each {b64} or {path}) or under an accumulator read from the chain in this call ({root: 'known-accumulator', chain: {genesis, rpcUrl, logId?} or {rpcUrl, univocity, logId?, chainId?}}). A genesis fetched in the same call is never the root. The result is the verifier's own: stages, the four questions (sealing, split-view, append-authority, attribution; not_answered_by_this_root is a real answer) and diagnostics, passed through unaltered, plus receipt_fetched_from_operator always and root_read_from_chain when the chain path was taken. If the latest chain state no longer holds the receipt's peak, the chain path walks CheckpointPublished history backwards within the bounds in chain.history (default 200000 blocks in windows of 10000, one eth_getLogs each) and verifies under the newest checkpoint that holds it, adding root_read_from_chain_history; running out of range is the structured problem history_scan_exhausted. The log read is the one you name, in chain.logId or in the receipt coordinates; if the receipt's delegation certificate names a different log, the result adds receipt_log_id_mismatch and the call still uses yours. If you name none, the call uses the certificate's log id and says so in provenance.logId, with source receipt-delegation-certificate. Supply payload bytes and the entry id to have attribution answered. The genesis root's offline walk resolves one delegation hop from the forest root: a receipt from a log further down the grant chain (the verifier's own publications log is a grandchild) fails under a supplied genesis with delegation_invalid, and the result adds genesis_root_reaches_direct_delegates_only to say that this is the walk's limit, not a finding about the receipt; verify such a receipt under known-log-key or known-accumulator.
Ready-to-paste client configs
Paste either block (or both) into your client config, e.g. claude_desktop_config.json or ~/.cursor/mcp.json. We only show a config when the install command is confirmed.
Firecrawl MCP Server
{
"mcpServers": {
"firecrawl-firecrawl-mcp-server": {
"command": "npx",
"args": [
"-y",
"firecrawl-mcp"
],
"env": {
"FIRECRAWL_API_KEY": "YOUR_FIRECRAWL_API_KEY_HERE",
"HTTP_STREAMABLE_SERVER": "YOUR_HTTP_STREAMABLE_SERVER_HERE",
"FIRECRAWL_NO_SEARCH_FEEDBACK": "YOUR_FIRECRAWL_NO_SEARCH_FEEDBACK_HERE",
"FIRECRAWL_NO_ENDPOINT_FEEDBACK": "YOUR_FIRECRAWL_NO_ENDPOINT_FEEDBACK_HERE"
}
}
}
}
Resolve
{
"mcpServers": {
"resolve": {
"command": "npx",
"args": [
"-y",
"@forestrie/mcp-resolve"
],
"env": {
"FORESTRIE_BASE_URL": "YOUR_FORESTRIE_BASE_URL_HERE",
"FORESTRIE_RPC_URL": "YOUR_FORESTRIE_RPC_URL_HERE"
}
}
}
}
Frequently asked questions
Firecrawl MCP Server is categorized under Search & Data Extraction and uses a local stdio subprocess. Resolve belongs to Cryptography and uses a local stdio subprocess. Pick Firecrawl MCP Server for search & data extraction work and Resolve for cryptography.
Copy the mcpServers block from the config section on this page into your client's config (for example claude_desktop_config.json or ~/.cursor/mcp.json), then fully restart the client.
Firecrawl MCP Server is listed as freemium — a free tier with paid plans. Auth: api key required. Resolve is listed as free. Auth: no auth required. If a server needs environment variables such as API keys, define them under the env key in your client's MCP config.
Yes. MCP clients support multiple servers: add firecrawl-firecrawl-mcp-server and resolve as separate keys in the same mcpServers object, and your assistant will call tools from either one.
On AllMCPs, Firecrawl MCP Server has a quality signal of 90/100 (Excellent) with 13 views, 0 installs and 7,642 GitHub stars. Resolve has 63/100 (Good) with 1 views, 0 installs and 0 GitHub stars.