# Changelog ## [3.41.0] - 2026-11-17 ### Added - Alexandria skills in the library, plus `firecrawl_save_skill` to write them. `alexandria_library_search` (and the `firecrawl/library` capability on surfaces without it) describes skills under `/library/skills`: `grep -i "" /library/skills/INDEX` lists skills one per line (path, a `[team-authored vN]` or `[firecrawl]` marker, `name: description`, the team's own first), and `cat` reads the path; when grep lists many, `cat /library/skills/search/` lists the best matches ranked, the team's first. `alexandria_library_search`'s description opens with a line to check `/library/skills` first for business workflows, and the server instructions of surfaces that list it carry the same line. A command run through `alexandria_library_search` that searches for something also asks `firecrawl/find-skills` (with `related: true` and the command's own search words only) for skills that fit, beside the command, and lists up to three matches under its output, the team's own first (a team skill matched on every query word, a Firecrawl skill at a similarity of 0.42 or more); the lookup is skipped for commands under `/library/skills` and for commands with too few search words, and is left out when it fails, is refused, finds nothing, or is still running 250 ms after the command answers. `firecrawl_save_skill` writes: without `id` it creates a team skill through `firecrawl/create-skill`, written out or copied `from` a skill (`` for `/library/skills/firecrawl/`, `team:` for `/library/skills/team/`); with `id` and `baseVersion` (the `version:` in the skill's SKILL.md) it changes one through `firecrawl/update-skill`, and a stale `baseVersion` is a conflict, returned as a tool error. It returns the saved skill's `path` and a `nextTool` that reads it through the library. Its schema refuses an update without `baseVersion` or a create with update-only fields before Exchange is called, and it is marked destructive because an update can overwrite or turn off a skill. There is no delete. It is free, needs an API key, and is hidden from keyless sessions. The `librarySkills: false` server option (`FIRECRAWL_MCP_LIBRARY_SKILLS=false` for the CLI) serves the library without skills: every `firecrawl/library` call carries `skills: false`, whichever tool makes it, the check-first line, the skills instructions and the related lookup are left out, and `firecrawl_save_skill` is not registered. - `jobs_search`: one tool for job postings over Alexandria's jobs route, `firecrawl/jobs/auto`, listed wherever the enrich tools are, including the search-only endpoint, whose fixed tool set grows from eleven to twelve. `query` with `location`, `remote` and `posted_within_days` searches postings by role and place; `url` reads one posting and tells whether it is still open; `urls` checks up to 10 postings in one call; `company` lists a company's open roles from its own job board; `group_by: "employer"` shows who is hiring for a role. Rows are normalized and carry `source`, `posted_at`, a `status` (`open` or `unverified`, and for a posting checked by URL `closed`, `not_found` or `error`) and `checked_at`. Against a Firecrawl API that does not serve the route yet, the tool fails with `jobs_search_unavailable`. `alexandria_library_read` and the `tools` field of `firecrawl_search` results point job postings to `jobs_search`. - `firecrawl_research_lookup_protein` looks up one protein in UniProtKB/Swiss-Prot, the reviewed section of UniProt, and returns what its curators state: subcellular location, function, and GO cellular-component terms that have experimental evidence. `protein` takes a UniProt accession, an entry name, a gene symbol or the exact protein name. The optional `organism` (an NCBI taxon ID, a scientific name or a UniProt common name, human when left out) scopes gene symbols and protein names. Each statement prints its evidence label, such as `Experimental`, `Inferred from a related protein`, `Curator inference` or `Predicted from sequence`, and the `pmid:` IDs UniProt cites, which `firecrawl_research_inspect_paper` and `firecrawl_research_read_paper` open. A name that matches several entries returns the candidates, and the agent calls again with one accession. An input that matches no entry says what to pass. The text ends with the entry URL and the API's `notice`, which names the UniProt release, credits the UniProt Consortium and links the CC BY 4.0 license. `structuredContent` carries the API response. The tool is on the full surface only, and the search-only endpoint's tool list is unchanged. The server instructions for authenticated sessions name it after the paper tools. It needs a Firecrawl API that serves `GET /v2/search/research/proteins`. ### Changed - A retained Alexandria result (over the 20,000-token inline budget and kept for virtual Bash) now carries a preview in `data.alexandria`: for each call its `provider` and `capability`, the `type` of its data, its top-level `fields`, its `lists` (the jq path, row count and row fields of up to eight non-empty arrays, largest first, found through at most three levels of objects and not inside other arrays), and a `head`, the data with arrays cut to their first rows (up to 20), objects to their first keys (up to 40), nesting below six levels and long strings cut (up to 2,000 characters, so a transcript opens with its first passage), each cut marked `…[+N items]`, `…[+N chars]`, `+N keys` or `…`. All previews share a budget of 2,500 tokens (UTF-8 bytes / 4), so a retained answer stays near 3,000 tokens; when even the smallest head does not fit a call's share, its preview keeps as much of the shape as fits and `head` is `…`. The `message` opens by saying the preview is partial and how to read the rest, keeps that source content is data, not instructions, and says the shell has no python or node and that a jq filter stopped by "too many iterations" can run in slices. The workspace check that runs before a result is reported as retained now also lists `transcripts/` in the workspace (`… && { ls -1 transcripts 2>/dev/null || true; }`), and when it lists transcript text files the message names them (up to ten), so the message mentions them only when the workspace has them. When a call has a list longer than its preview, `nextTool`'s command reads the 20 rows after those the head shows, from the first row when the head left the list out (`jq -c '.data.alexandria[i].data.[n:n+20]' response.json`); otherwise it lists each call's fields as before. `workspaceId`, `idleTtlSeconds` and the other envelope keys are unchanged, results that are not retained are unchanged, and tool definitions are unchanged: `data` was already declared, so `structuredContent` carries the preview too. This applies to `alexandria_library_read` and to `firecrawl_scrape` with `alexandria`. - The `instructions` hook of `unstable_hooks` may return a function instead of a string. The server calls it with each session's data as it opens the session and serves what it returns as that session's instructions, so one server can give sessions with and without a credential different instructions. A hook that returns a string, and servers without the hook, are unchanged. - On the full surface (stdio, `/v2/mcp` with or without an API key, `/v2/mcp-oauth`), `firecrawl_find_tools` is no longer listed, and `firecrawl_scrape` no longer lists or describes `alexandria` and `requestId`: its listed schema takes `url`, and its description points to `alexandria_library_search` and `alexandria_library_read`. Both still answer the calls they used to, so sessions and prompts that learned them keep working. `toolDetail` and `domainTools` stay on `firecrawl_scrape` for the website-matched tools of a scraped page. The search-only endpoint and surfaces whose `toolFilter` leaves a library tool out keep listing both, unchanged. - `firecrawl_gov_search` asks `/v2/search/gov` for `sources=gov` and returns the `gov` results. Each row in `structuredContent.results` keeps `url`, `title`, `description` and `position`, and also carries the index's labels when it has them: `jurisdiction`, `court`, `courtType`, `cites`, `citedAs`, `lang` and `updatedAt`. The text block, the tool description and the input schema are unchanged. An API that does not accept `sources` yet refuses it with a 400; the tool then repeats the call without it and returns the `web` results as before. ### Fixed - `pdfOptions` reach the API when the call does not also set `parsers`. They were sent only when the call listed `parsers: ["pdf"]`, so `pdfOptions.maxPages` on its own did not limit the pages parsed. `firecrawl_scrape`, `firecrawl_parse` and the `scrapeOptions` of `firecrawl_search`, `firecrawl_crawl` and `firecrawl_interact` now send `parsers: [{"type": "pdf", "maxPages": n}]` in both cases. Tool definitions are unchanged. ## [3.40.0] - 2026-11-12 ### Added - `alexandria_library_search` explores the Alexandria catalogue as a read-only filesystem with one shell command per call (`ls`, `grep`, `cat`, `jq`, pipes). `/library///.md` holds one contract per capability, every folder has a `README.md`, and recorded responses are under `/examples`. The result is the command's output as text, with `stdout`, `stderr` and `exitCode` in `structuredContent`. It is free, runs no provider, and needs an Alexandria API that serves `firecrawl/library`. - `alexandria_library_read` runs Alexandria capabilities: `calls` is an array of one to ten `{provider, capability, options}` entries (each optionally with `version`), which may name different providers, with optional `requestId` and `timeout`. The result envelope is the one `firecrawl_scrape` with `alexandria` returned, with one result per call, in the same order, in `data.alexandria`. ### Changed - On the full surface (stdio, `/v2/mcp`, `/v2/mcp-oauth`), Alexandria has its own tools, `alexandria_library_search` and `alexandria_library_read`. The earlier paths keep working: - `firecrawl_scrape` and `firecrawl_find_tools` stay listed beside the new tools, with the definitions they had before them: `firecrawl_scrape` lists and describes `alexandria` and `requestId` and runs the call or batch exactly as before, and `firecrawl_find_tools` answers as before. A client that takes up a new or changed tool only after its own review keeps catalogue discovery and provider execution in the meantime, and clients and prompts that learned these shapes keep working. - `alexandria_library_read` lists `calls` only. It also reads an `alexandria` body (one call or an array) and one call sent as the arguments themselves (`{provider, capability, options}`) as `calls`. - Follow-up calls in results (`nextTool` for provider terms, for a retained result, and `next_tool` for a pending enrichment job) are addressed to `alexandria_library_read`. - Server instructions, the `firecrawl_search` description and its `toolDetail` and `query` parameters name the new tools. - An embedder whose `toolFilter` leaves either new tool out keeps `firecrawl_find_tools` and `firecrawl_scrape` with `alexandria` listed, with the earlier copy. - The search-only endpoint is unchanged: it keeps listing `firecrawl_find_tools` and `firecrawl_scrape` with `alexandria`, because its tool list is fixed by its connector listing. - The `max_credits` description on `people_company_search` and `people_company_enrich` says to set it only to a budget the user gave. Left out, it is 1000 on `people_company_search`, and a `people_company_enrich` call has no cap. The `people_company_search` description no longer says that 0 runs only free calls. The `people_company_enrich` description says that 0 runs nothing paid, because a provider is tried only while its listed price still fits. Neither tool refuses a call with `max_credits_exceeded` any more: a provider whose price would pass the cap is not started, and a search that stops for the cap reports `stopped: "max_credits"`. - A stdio server pointed at its own API with `FIRECRAWL_API_URL` sends Alexandria tools to that API even when it has no API key itself, where before it refused them with "Alexandria requires an API key on a team with Alexandria access" and made no request. This is for [Firecrawl Local](https://github.com/firecrawl/firecrawl/tree/main/apps/local), which runs this server against its loopback API and holds the user's login there: someone with no account now gets its answer, which says how to sign in, and a login made while the server is running takes effect without a restart. A self-hosted instance answers for itself the same way. A keyless stdio server with no `FIRECRAWL_API_URL`, and every HTTP transport, behave as before. - Tool wording: `people_company_enrich` opens with when to use it (a named person or company) and that one call runs the provider waterfall; its argument refusals show a company example beside the people one. `alexandria_library_read` and the `tools` field of `firecrawl_search` results point people and company enrichment or search to `people_company_enrich` and `people_company_search`, naming a provider only when the user asks for it. - `people_company_enrich` runs Firecrawl's enrichment waterfall instead of taking a block per provider. It takes `people` (`name`, `first_name`, `last_name`, `company`, `domain`, `linkedin_url`, `email`, `phone`) and `companies` (`domain`, `name`, `linkedin_url`), at most 10 records per call, plus `contact_fields` and `max_credits`. For each requested field Firecrawl tries the providers that can use the inputs, one at a time, ordered by listed price and past success rate, and stops at the first one that finds it. Each record's `results` carry the raw response of each provider that found something, tagged with the provider. A hit is charged its listed price, a miss is free, and the call is uncapped unless `max_credits` is set. Mobile is opt-in: phone providers run and bill only when `contact_fields` lists `mobile`. With `contact_fields` each person also gets the profile in the same call (`profile: false` skips it). Each record has per-field `fields` flags (provider, and for emails the address, `verified` and `domain_match`), and `verified_only: true` returns only verified emails. The `apollo`, `fullenrich`, `people_data_labs` and `datalegion` blocks are removed; to call one specific provider, use `alexandria_library_read` (or `firecrawl_scrape` with an alexandria body on surfaces without the dedicated Alexandria tools). A phone number is now accepted as a person's identifier. - `people_company_search` runs Firecrawl's search waterfall (`firecrawl/search/auto`) instead of taking a block per provider. It takes `entity`, an optional `query`, `filters` (`titles`, `seniority`, `functions`, `company_domains`, `locations`, `industries`, `technologies`, `keywords`, `headcount`, `founded_year`), `limit` (1 to 100, default 10), `cursor`, `count_only` and `max_credits` (default 1000). Providers run one at a time in list-price order, and only those that apply every filter given; when none does, a company search feeds its domains into a people search, and a request no provider or chain covers is refused with `unsupported_filters`, naming the filter to drop. With `company_domains` the search stops at the first provider that returns rows; otherwise it fills `limit` across up to three providers. A row whose own title, employer domain, country or city, headcount or founding year fails a filter given, or whose title names another seniority level or function than those given, is dropped and counted as `dropped` on its provider. A kept row whose title names no level or function for a `seniority` or `functions` filter is counted as `unverified`. SVP, EVP and AVP titles meet a `vp` filter. Rows are normalized (name, title, `title_match`, company, location, LinkedIn URL, `source`) and never carry emails or phones, and `providers` traces each provider call. A request naming one person is refused with `use_enrich`. The `apollo`, `fullenrich` and `people_data_labs` blocks are replaced by an optional `provider`, with `options` for that provider's own search options. The `firecrawl_search` block is removed: call `firecrawl_search` for web results. ### Fixed - `people_company_search` declares `credits_pending` (top level and on each provider) in its output schema. A search where a provider timed out now returns its result instead of failing the client's output-schema check. ## [3.39.0] - 2026-11-09 ### Added - `people_company_enrich` accepts `people` and `companies` in the same call, in one provider block or across blocks. Each kind runs as its own request and is reported as its own `providers` entry with `kind: "people"` or `kind: "companies"`, so a provider given both has two entries, each with its own records, `input_index` into that kind's list, credits and errors. One kind failing does not fail the other. `max_credits` is checked against the estimate for both. `contact_fields` applies to the people, and companies in the same call get firmographics. Such calls used to be refused with `Give exactly one of people or companies` or `Send people and companies in separate calls`. Every `people_company_enrich` entry for a provider that ran now carries `kind`. ### Changed - `firecrawl_scrape` no longer advertises the `json` format or `jsonOptions`. Cached calls using them keep the existing JSON extraction, validation and results for compatibility. Other formats and tools are unchanged. - A `people_company_search` or `people_company_enrich` call that fails only because a provider's terms are not yet accepted for the organization fails with `third_party_data_terms_required` instead of `no_provider_ran`. The error names the provider, its terms version and the dashboard page where an organization admin accepts them. It also gives an example call without that provider, with `max_credits` set high enough for it to run. The provider's `note`, which agents also see when another provider failed or succeeded in the same call, now says to retry without it, names a provider that did not fail in the call, or says to wait for acceptance. It used to say not to retry until the terms were accepted. Both tool descriptions say Apollo runs once an organization admin has accepted its terms. - `people_company_search` and `people_company_enrich` state their limits and rules in the tool descriptions and repair or explain more mistakes: - A page size above its maximum (Apollo `per_page` 25, FullEnrich `limit` 25, People Data Labs `limit` 10) runs at the maximum with a `note`, where it used to be refused. The maximum is in each field's description and advertised schema. - A call whose every provider block errors or is skipped fails with `no_provider_ran`, each provider's reason, the credits charged and an example of a working call. It used to return a normal result with only errored or skipped providers. The per-provider report is still in `structuredContent`. - The `firecrawl_search` block is estimated at its listed price, 2 credits per 10 results (10 with enterprise zdr), without the 2 credits per result a team that scans results pays. That charge is described, and `max_credits` does not count it. - `entity` is described as required, exactly `"person"` or `"company"` (plural and `organization` forms are still read as these, as before). A call without it, or with any other value, is refused with an error that names it, every unknown top-level field and an example call. - The `max_credits` description says how the estimate is made and that 0 runs only free calls. A `max_credits_exceeded` error gives the minimum `max_credits`, and the same call raised to it when the call is short enough to quote. - `contact_fields` is described as people only. Every argument error that reaches schema validation names all invalid fields, not the first five, and every enrich shape error (no provider, a block with neither people nor companies, `contact_fields` with companies only) includes an example call, built from the caller's own arguments when they are short. - `firecrawl_agent` and `people_company_enrich` are annotated `readOnlyHint: true`. Both read the web or provider data and return it. They spend credits but change nothing on the web or in the account, so clients that confirm non-read-only tools first, such as Hermes with `trust: untrusted`, no longer ask before every research or enrichment call. `max_credits` / `maxCredits` still cap what a call can spend. - `firecrawl_find_tools` is marked always-load (`_meta["anthropic/alwaysLoad"]`), so clients that defer MCP tools behind a tool search, such as Claude Code, list it with the agent's other tools from the first turn. Its description no longer tells the agent to prefer `firecrawl_search` for data tasks. In agent evals, both changes together made agents look up and run Alexandria providers on data tasks much more often, with no extra lookups on tasks that need only the web. ### Fixed - A provider call the API refused before any provider ran (`retryable: true`: an agreement, quote or credit-reservation outage) is resent once, after 300-500 ms, when the call can safely repeat: an Alexandria scrape or enrich chunk pinned to its request id, or a catalogue read. A resend stays inside the caller's `timeout` and is skipped when too little of it is left. A retryable refusal now reaches the agent with its `retryable` flag, and the enrich report marks `precheck_unavailable` and `billing_unavailable` retryable. - More argument mistakes are refused as tool errors with an error code, like the json format check: a `query` format without `queryOptions.prompt` in `firecrawl_scrape` and in `firecrawl_interact` `scrapeOptions` (`invalid_request`, with the text `formats "query" needs queryOptions with a non-empty prompt.` in place of the SDK's `query format requires a non-empty 'prompt' string`), a `json` format without a prompt or schema in `firecrawl_interact` `scrapeOptions` (`invalid_request`), and the input checks of `firecrawl_find_tools`, `firecrawl_monitor_create` and `firecrawl_credit_usage` (`invalid_input`). The error code reaches `onToolResult` on the thrown `UserError`'s `extras`, and for the `invalid_input` tools only there: their `outputSchema` does not declare `code`, so the code is not in the client's `structuredContent`. The text block no longer carries the `Tool '' execution failed:` prefix for these errors. ## [3.38.0] - 2026-11-06 ### Added - Per-call feedback tokens for Alexandria. Alexandria call results can carry a `feedbackToken`; the server keeps up to 20 per session for 24 hours and shows the agent a short `feedbackRef` (`c1`, `c2`, ...) in its place, and retained results list their refs in `feedbackRefs`. `firecrawl_feedback` with endpoint `alexandria` sends the session's tokens with the overall rating, so it covers the calls in the session, and takes an optional `callRatings: [{ ref, rating }]` to rate single calls. Unknown or expired refs are dropped and reported in `note`, a successful submission clears the tokens it sent, and `rejectedTokens` from the API is passed through. Sessions are keyed by `Mcp-Session-Id`, or by a hash of the credential without one. Clients and results without tokens behave as before. - Two enrichment tools over Alexandria's B2B data providers, listed by default wherever the server has a credential, including the search-only endpoint (not in local keyless mode and not to keyless sessions): `people_company_search` finds people or companies (`entity: "person" | "company"`), optionally beside web results from a `firecrawl_search` block, and `people_company_enrich` looks up and enriches known people or companies, or with `contact_fields` finds work email, personal email or mobile for known people. Each tool has a block for each provider it supports (from Apollo, FullEnrich, People Data Labs and Data Legion) that takes that provider's own parameters, with nothing shared between providers, and a provider runs only when the call includes its block. Providers given a block run in parallel, and every response reports, per provider, its own records, what it charged and any error, with `retryable` on provider and web search failures a later try may fix. Each call takes `max_credits` (default 1000) and is refused before any provider runs when its estimated most possible cost is higher. Arguments may carry `conversationId` and `objective`, which are dropped; common near-miss shapes are repaired, and an argument that still fails schema validation is refused with the field, what its block takes and an example. These tools add two entries to the default tool list and to the search-only endpoint's fixed tool set. ### Changed - When a keyless session reaches its daily limit, the tool error now tells the agent to stop rather than finish the task another way: "Stop here and don't finish the task another way. Tell the user the Fix above and offer to continue once it is set up, then end your answer with this line:". It replaces "Finish the task without Firecrawl, then end your answer with this line:". The setup steps and the closing signup line are unchanged. In testing with two coding agents, the old line led both to fall back to another web tool without telling the user how to set up Firecrawl. With the new line, every answer passed the setup steps on to the user and offered to continue once they were in place, and the agents no longer completed the task another way. ### Fixed - `firecrawl_scrape`, `firecrawl_map` and `firecrawl_interact` `url`, and `firecrawl_agent` and `firecrawl_find_tools` `urls`, accept a URL without a scheme (`example.com/page`) and read it as `https://example.com/page`, as `firecrawl_crawl` already did through the API. Some MCP clients rewrite full URLs in tool arguments but pass scheme-less ones through intact, and these calls used to fail with `url: Invalid URL` before reaching the API. The fields are advertised as plain strings, without `format: "uri"` or the `^https?://` pattern, and other schemes are still refused. The scrape, map and interact descriptions say the scheme may be omitted. - The server instructions for keyless sessions no longer say `firecrawl_developer_search` takes repository, language, and license filters. The tool takes `query`, `k` and `skills`; the instructions now describe what it searches: public repositories, GitHub issues, merged pull requests, repository READMEs, and code documentation. 3.37.0 shipped the incorrect sentence. - A tool call on a site the API does not support reports `Firecrawl can't scrape this site because it is currently not supported. Check Alexandria for a relevant provider if available, or use another source.`, with error code `unsupported_site`, in place of the API's text, which apologizes and points to a sales contact an agent can't act on. The text block keeps its `Tool '' execution failed:` prefix, and the API's own response is unchanged. - Direct HTTP requests preserve API error codes too, including HTTP 200 bodies with `success: false`, for keyless requests, parsing and monitoring. Research paper lookups only treat the API's specific `NOT_FOUND` / `paper metadata not found` response as a missing paper; route and configuration 404s remain errors. - A scrape the API answers with HTTP 200, `success: false` and an error code, as it does when the host has no DNS record (`SCRAPE_DNS_RESOLUTION_ERROR`), is reported like any other failed API request: the error result carries `structuredContent` with `success: false` and `error: { code, status, message }`. It used to carry only the text block, unlike every other API failure, and some clients showed such results as a bare tool error without the API's explanation. - `firecrawl_scrape` refuses `formats: ["json"]` without a `jsonOptions` prompt or schema with `formats "json" needs jsonOptions with a prompt or a schema. To ask a question about the page, use formats ["query"] with queryOptions.prompt instead.`, and `structuredContent` with error code `invalid_request`. The SDK already refused these calls before sending them, with a plain error that reached clients as text alone, so some showed a bare tool error. Agents that hit it had often put their question in `queryOptions`. Keyless scrapes, which the API accepts without a prompt or schema, are unchanged. - `firecrawl_research_read_paper` and `firecrawl_research_inspect_paper` report a paper ID the research index does not know as `(paper not found: no indexed paper has the ID "". Use a paperId or primaryId from firecrawl_research_search_papers results.)`, with `passages: []` and no `paper` in `structuredContent`, as their output schemas describe. The API answers such an ID with 404, and both tools used to fail with `Request failed with status code 404` as text alone, which some clients showed as a bare tool error. - `firecrawl_feedback` accepts `objective`, `rationale`, `requestedWebsite`, `providerFeedback` and `capabilityFeedback` on `search`, `scrape`, `parse` and `map` feedback. The tool advertises these fields, and agents often carry `objective` over from their search and scrape calls, but a job feedback call that included one failed validation with " is only supported for Alexandria feedback" and was never sent. They are left out of the `/v2/feedback` body, which rejects unknown keys, except that `rationale` is sent as `note` when the call has no `note`. Alexandria feedback, and the advertised input schema, are unchanged. - `firecrawl_feedback` and `firecrawl_search_feedback` add the API's validation messages to `error` when it rejects a body with `INVALID_BODY`, for example `Invalid request body: Feedback must be substantive. 'good' requires valuableSources or valuableResults; ...`. The error used to read only `Invalid request body`, so an agent could not tell which rule its call broke and sent the same call again. Other rejections read as before, and the output schema is unchanged. ## [3.37.0] - 2026-11-04 ### Added - `firecrawl_research_search_papers` takes `sort`: `relevance` (default) or `date_desc`, which returns the newest of the most relevant matches. - `firecrawl_research_search_papers` and `firecrawl_research_related_papers` print authors and created and updated dates when the result includes them. ### Changed - The server instructions for keyless sessions list `firecrawl_research_*` for paper-index research only and name `firecrawl_developer_search` among the tools an API key exposes. The README points GitHub repository, issue and pull request research to `firecrawl_developer_search`. ## [3.36.1] - 2026-11-03 ### Changed - The `firecrawl` JS SDK dependency moves from 4.50.0 to 4.51.0. That release adds the Government Index filters (`jurisdiction`, `court`, `courtType`, `cites`, `domain`) to the SDK's `govSearch`, `location` and `zeroDataRetention` to agent requests, and `insufficient_credits` and `zeroDataRetention` to the agent trace types. The server uses none of them: `firecrawl_gov_search` already sends its filters through the SDK's HTTP client, and `firecrawl_agent` offers neither `location` nor `zeroDataRetention`, so tools, schemas and results are unchanged. ### Fixed - The Gemini CLI extension starts the firecrawl-mcp release it ships, `npx -y firecrawl-mcp@3.36.1`, instead of `npx -y firecrawl-mcp`. Without a version, npm picks the newest release whose `engines` accepts the running Node, so on Node 20, which Gemini CLI supports, the extension ran firecrawl-mcp 3.22.2. npm installs an exact version as asked, and 3.36.1 starts on Node 20 with an engine warning. The pin moves with each release: a test checks that it matches the package version. ## [3.36.0] - 2026-10-27 ### Changed - Local HTTP mode (`HTTP_STREAMABLE_SERVER=true` or `SSE_LOCAL=true` without `CLOUD_SERVICE=true`) checks the `Host` and `Origin` headers. It answers `localhost`, `127.0.0.1` and `[::1]` on any port, the address in `HOST` unless it is `0.0.0.0` or `::`, and the hosts listed in the new `FIRECRAWL_MCP_ALLOWED_HOSTS` (comma-separated). Any other `Host`, or an `Origin` naming any other host (including `null`), gets `403` with a JSON-RPC error, and the server logs a warning that names `FIRECRAWL_MCP_ALLOWED_HOSTS`, so a web page can't reach the server through DNS rebinding or a cross-origin request and spend the configured `FIRECRAWL_API_KEY`. CORS headers echo an allowed origin, with `Vary: Origin`, instead of `Access-Control-Allow-Origin: *`. `GET` and `HEAD` requests to `/health` are answered for any host, so health checks that address the server by IP keep working; they get no CORS allow for other origins. Clients that reach the server under another name, such as a LAN address or a reverse-proxy hostname, need that name in `FIRECRAWL_MCP_ALLOWED_HOSTS`; `FIRECRAWL_MCP_ALLOWED_HOSTS=*` restores the previous behaviour. `CLOUD_SERVICE=true` and stdio are unchanged. - The `firecrawl_scrape` description's Alexandria contract guidance says "a key field under response" instead of `response.key`. Some MCP gateways scan tool descriptions for sensitive file names, read `response.key` as a private key file, and flagged the tool. ### Fixed - `tools/list` advertises record-typed inputs as open objects again. Since 3.35.0 they were advertised with `additionalProperties: false` and no properties, which allows only `{}`, so clients that validate arguments against the advertised schema before sending a call refused any real value. The server's own validation accepted them throughout. The affected fields are `jsonOptions.schema` on `firecrawl_scrape` and `firecrawl_parse`, `scrapeOptions.jsonOptions.schema` on `firecrawl_search`, `firecrawl_crawl` and `firecrawl_interact`, `schema` on `firecrawl_agent`, `webhookHeaders` on `firecrawl_crawl` (now `additionalProperties: { type: "string" }`), `metadata` on `firecrawl_feedback`, and `body` on `firecrawl_monitor_create` and `firecrawl_monitor_update`; the rest advertise `additionalProperties: {}`. Every other input schema, and every output schema, is unchanged. - stdio no longer starts when authentication fails. If an `unstable_hooks.authenticate` hook throws, returns nothing or returns `{ authenticated: false }`, `start({ transportType: 'stdio' })` now rejects with `Authentication failed for stdio transport: `, and the `firecrawl-mcp` command prints `[firecrawl-mcp] Failed to start:` with that error and exits with status 1. Before, the server logged the failure and served every tool without a session. The built-in stdio authentication doesn't fail, so the command is unaffected unless a hook is supplied: a missing `FIRECRAWL_API_KEY` still starts keyless mode, and a key the API rejects is still reported on each tool call. - `GET /sse` answers an authentication failure with `401` and the same JSON-RPC error body and `WWW-Authenticate` challenge as the Streamable HTTP endpoint. It used to answer `500 Error creating server` when the hook threw an error that wasn't a `Response`, returned nothing or returned `{ authenticated: false }`. A `Response` thrown by the hook is still sent as is. - The Streamable HTTP endpoint and `GET /sse` check the `Host` header before they call the authentication hook, so a malformed `Host` gets `400` without a credential check, also when the request target is in absolute form. `/sse` didn't check `Host` before. It accepts IPv6 literals in any valid spelling (`[::1]`, `[0:0:0:0:0:0:0:1]:8080`) and host names in any case with a port (`EXAMPLE.COM:8080`), which used to get `400`. - A server bound to an IPv6 address (`httpStream.host: '::'`) serves `/health`, `/ready` and the protected-resource metadata. They used to fail with `500`. - `WWW-Authenticate` challenges escape backslashes as well as quotes, and turn line breaks, other control characters and non-ASCII characters into spaces. An error message with a line break used to make the response fail with `500`. The JSON-RPC error message keeps the original text. - Authentication errors on the HTTP endpoints are logged through the server logger (`[ERROR]