# Open source web search MCP Open source web search MCP servers give your agent search and page reading without a vendor bill. We ran one Wikipedia page through 6 of them with default settings. SearXNG put **117,088 tokens** in context, Crawl4AI **74,896**, open-webSearch **11,609**, and mcp-server-fetch's default call missed the answer. FATSEARCH answered in **1,384** across three reads. > We make FATSEARCH. The numbers below are our own runs, dated. Where another reader is the better pick, we say so. | Reader | Tokens in context | Answer found | Model bill | | --- | --- | --- | --- | | FATSEARCH (2026-10-17) | 1,384 | yes | $0.0028 | | mcp-server-fetch (2026-10-19) | 2,373 | no | $0.0047 | | Crawl4AI (2026-10-19) | 74,896 | yes | $0.15 | | SearXNG + mcp-searxng (2026-10-19) | 117,088 | yes | $0.23 | | open-webSearch (2026-10-19) | 11,609 | yes | $0.02 | | Firecrawl self-hosted (2026-10-19) | 107,332 | yes | $0.21 | Columns 2–4: 2026-10-17 and 2026-10-19 (each row: its own day), Wikipedia “Rust (programming language)” (https://en.wikipedia.org/wiki/Rust_(programming_language)), one run each; model bill at $2/M input tokens (Claude Sonnet 5.5). Each row is the tool’s default call, the one an agent gets unless it asks for more. mcp-server-fetch, another call. With max_length 999999 (its maximum), the whole page in one call: 76,147 tokens, answer found. Crawl4AI, another call. With the bm25 filter and our question as the query: 36,307 tokens, answer found. SearXNG + mcp-searxng, another call. Its headings first, then two sections picked from them (readHeadings, section): 3,037 tokens, answer found. open-webSearch, another call. With maxChars 200000 (its maximum), the whole page: 34,881 tokens, answer found. Firecrawl self-hosted, another call. Through firecrawl-mcp (firecrawl_scrape), the tool text an agent gets: 113,609 tokens, answer found. | Tool | Licence | API key | Does | | --- | --- | --- | --- | | FATSEARCH | MIT OR Apache-2.0 | None to read; search needs your Oxylabs or Bright Data key | Search + read (outline, then one section) | | mcp-server-fetch | MIT | None | Read only | | Crawl4AI | Apache-2.0 + attribution clause | None from a vendor; you set your own server token | Read + crawl; no web search in the open-source server | | SearXNG + mcp-searxng | MIT (mcp-searxng), AGPL-3.0 (SearXNG) | None; you run SearXNG | Search + read | | open-webSearch | Apache-2.0 | None | Search + read | | Firecrawl self-hosted | AGPL-3.0 (server), MIT (firecrawl-mcp) | None with auth off, the guide's local default | Search + read + crawl (we did not test its search) | ## How we measured - **Same page, same question.** Wikipedia's Rust article; we asked who created Rust and what safe Rust guarantees. It is the page and answer check from our [hosted readers run](/compare/) on 2026-10-17. The open-source tools ran on 2026-10-19, on a Mac, in Docker where the tool needs it. FATSEARCH ran again that day and returned the same counts. - **The default call is the row**, because that's what an agent gets unless it asks for more. Two tools cut long pages by default: mcp-server-fetch at `max_length: 5000` characters (the answer wasn't in that part) and open-webSearch at `maxChars: 30000` (it was). The notes under the table give their full-length numbers. - **Reading, not search quality.** This counts what each tool puts in the model's context for one page, with Anthropic's tokenizer. One run each is a sample, not a ranking. ## Free web search MCP: which ones search without a key Two of these search for free. SearXNG is a metasearch engine you host; mcp-searxng hands its results to your agent. open-webSearch needs no server: it scrapes results from Bing, DuckDuckGo and other engines. On our run its default engine, Bing, failed from our IP; DuckDuckGo worked. The others read more than they search. mcp-server-fetch only reads. Crawl4AI's open-source server crawls and reads; web search is in Crawl4AI Cloud, not in the server you run. Self-hosted Firecrawl has a search route we didn't test. FATSEARCH reads plain pages for free and searches through your own Oxylabs or Bright Data key. Free software still has a running cost: the tokens it hands the model. At $2/M input tokens, SearXNG's whole-page read costs **$0.23** each time, Crawl4AI's **$0.15**, and the FATSEARCH reads **$0.0028**. ## Local web search MCP: local process or self-hosted server "Local" covers two setups. mcp-server-fetch (uvx), open-webSearch and mcp-searxng (npx) and FATSEARCH (one binary) start as a process next to your agent. SearXNG, Crawl4AI and Firecrawl are servers you run and keep updated: we ran SearXNG and Crawl4AI as Docker containers and Firecrawl as a Docker Compose stack of several services. Crawl4AI's server won't answer on a published port until you set your own token. Firecrawl's guide says you own the upgrades, storage and security. ## Open source web search tool for LLM: whole page or one section Most of these tools hand the model the whole page. That is where the token counts come from: Firecrawl self-hosted returned **107,332** tokens for one article. Some can read less. mcp-searxng can list a page's headings and read one section: that path cost **3,037** tokens and found the answer. Crawl4AI can filter a page by a query: **36,307**. FATSEARCH reads an outline first, then the one section the question needs. A fixed cut is luck. open-webSearch's default length happened to include the answer; mcp-server-fetch's didn't. Both keep the top of the page, whatever the question was. For the hosted side, see [Firecrawl alternatives](/compare/firecrawl-alternatives/) and [Tavily alternatives](/compare/tavily-alternatives/). For the two crawlers head to head: [Crawl4AI vs Firecrawl](/compare/crawl4ai-vs-firecrawl/). Connecting any of them to Claude Code: [web search MCP for Claude Code](/guides/web-search-mcp-for-claude-code/). ## Acknowledgments Crawl4AI's licence asks publications to credit it: "This product includes software developed by UncleCode (https://x.com/unclecode) as part of the Crawl4AI project (https://github.com/unclecode/crawl4ai)." ## FATSEARCH Local CLI + MCP server, your own provider key. Measured: outline, then one filter, then one section (plain HTTP, $0). ```text = j11.u46 Rust (programming language) - Wikipedia · en.wikipedia.org · 57 sections · 6 photos · 2 videos · 40.9ktok · pl… u46#0 info | author Contributors to Wikimedia projects · published 2010-10-30T22:30:54Z · modified 2026-10-15T20:56:59Z m1 photo 250x167 png | A bright orange crab icon → https://thumb.wikimedia.org/wikipedia/commons/thumb/2/20/Rustacean-or… m2 photo 250x314 png | (no alt) → https://thumb.wikimedia.org/wikipedia/commons/thumb/a/af/Rust_standard_libraries.svg/5… m3 photo 250x193 png | (no alt) → https://thumb.wikimedia.org/wikipedia/commons/thumb/6/6c/Cargo_clippy_hello_world_exam… … +10 media → fats u46 media u46#1 (top) (9) | Jump to content u46#9 Syntax and features (9.2k, 27 sub) | [edit [l175] ] Main article: Rust syntax [l176] Rust's syntax [l177] is simil… ``` Price: $0.001–0.0065 per hard page, $0 plain pages (https://github.com/fatsearch/fatsearch#readme, checked 2026-10-21) Install, from its own docs (https://github.com/fatsearch/fatsearch#readme, https://github.com/fatsearch/fatsearch/blob/main/docs/reference.md, checked 2026-10-19): ```text npm i -g fatsearch claude mcp add --scope user fats -- fats mcp ``` ## mcp-server-fetch Reference fetch server from the MCP project, runs on your machine. Measured: fetch tool, default max_length of 5,000 characters: one call, the top of the page, cut with a hint to read on from start_index 5000. ```text Contents of https://en.wikipedia.org/wiki/Rust_(programming_language): | Rust | | | --- | --- | | [Rust logo: a capital letter R attached inside a sprocket with teeth on the outside, both black on a white background]… | [Paradigms](https://en.wikipedia.org/wiki/Programming_paradigm "Programming paradigm") | * [Multi-paradigm](https://en… | [Developer](https://en.wikipedia.org/wiki/Software_developer "Software developer") | The Rust Team | | First appeared | January 20, 2012; 14 years ago[[1]](#cite_note-Rust0.1a-1) | | | | ``` Price: Free and open source (MIT). Runs on your machine; no API key. (https://github.com/modelcontextprotocol/servers/blob/main/src/fetch/LICENSE, https://github.com/modelcontextprotocol/servers/tree/main/src/fetch#readme, checked 2026-10-19) Install, from its own docs (https://github.com/modelcontextprotocol/servers/tree/main/src/fetch#readme, https://github.com/modelcontextprotocol/servers/blob/main/src/fetch/LICENSE, checked 2026-10-19): ```text {"command": "uvx", "args": ["mcp-server-fetch"]} ``` When it's better: You only read pages and want the smallest setup. It is the reference fetch server from the MCP project: one uvx line, no account, no Docker. Its README says the tool cuts long pages and the model reads on with start_index, or you raise max_length. At the default length the answer to our question was not in the text. ## Crawl4AI Self-hosted crawler in Docker with an MCP endpoint. Measured: Docker server 0.9.5, MCP md tool, default filter fit. ```text {"url": "https://en.wikipedia.org/wiki/Rust_(programming_language)", "filter": "fit", "query": null, "cache": "0", "mark… ``` Price: Free and open source (Apache-2.0 with an added attribution requirement). You run the Docker server; no API key (it asks you to set your own server token). (https://github.com/unclecode/crawl4ai/blob/main/LICENSE, https://docs.crawl4ai.com/core/self-hosting/, checked 2026-10-19) Install, from its own docs (https://docs.crawl4ai.com/core/self-hosting/, https://github.com/unclecode/crawl4ai/blob/main/LICENSE, checked 2026-10-19): ```text docker run -d -p 11235:11235 --name crawl4ai --shm-size=1g \ -e CRAWL4AI_API_TOKEN="$CRAWL4AI_API_TOKEN" unclecode/crawl4ai:latest claude mcp add --transport sse c4ai-sse http://localhost:11235/mcp/sse ``` When it's better: You want to crawl, not just read. Crawl4AI runs a real browser in Docker on your machine. Its MCP tools crawl many pages, take screenshots and PDFs, run JavaScript on a page, and can filter a page by a query. It is also a Python library. The open-source server has no web search; FATSEARCH has no crawler. ## SearXNG + mcp-searxng Local MCP server (mcp-searxng) over a SearXNG instance you run. Measured: web_url_read, default (whole page as Markdown). ```text [Jump to content](#bodyContent) Main menu Main menu move to sidebar hide Navigation * [Main page](/wiki/Main%5FPage "Visit the main page [z]") * [Contents](/wiki/Wikipedia:Contents "Guides to browsing Wikipedia") * [Current events](/wiki/Portal:Current%5Fevents "Articles related to current events") ``` Price: Free and open source: mcp-searxng is MIT, SearXNG is AGPL-3.0. You run SearXNG yourself; no API key. (https://github.com/ihor-sokoliuk/mcp-searxng/blob/main/LICENSE, https://github.com/searxng/searxng/blob/master/LICENSE, checked 2026-10-19) Install, from its own docs (https://github.com/ihor-sokoliuk/mcp-searxng#readme, https://docs.searxng.org/, checked 2026-10-19): ```text {"command": "npx", "args": ["-y", "mcp-searxng"], "env": {"SEARXNG_URL": "https://search.example.com"}} ``` When it's better: You want private search with no API key and no bill. SearXNG is a metasearch engine you host: it asks many search services at once, and its docs say users are neither tracked nor profiled. mcp-searxng adds a page reader that can list a page's headings and read one section, close to how FATSEARCH reads. ## open-webSearch Local MCP server: keyless search on several engines, plus page fetch. Measured: fetchWebContent, default maxChars of 30,000 (cut, and it says truncated). ```text "url": "https://en.wikipedia.org/wiki/Rust_(programming_language)", "finalUrl": "https://en.wikipedia.org/wiki/Rust_(programming_language)", "contentType": "text/html; charset=utf-8", "title": "Rust (programming language) - Wikipedia", "retrievalMethod": "request", "truncated": true, "content": "Toggle the table of contents\n\n\t\t\t\t\tRust (programming language)\n\n59 languages\n\n\t\t\t\tAfrikaans… ``` Price: Free and open source (Apache-2.0). Runs on your machine; no API key. (https://github.com/Aas-ee/open-webSearch/blob/main/LICENSE, https://github.com/Aas-ee/open-webSearch#readme, checked 2026-10-19) Install, from its own docs (https://github.com/Aas-ee/open-webSearch#readme, https://github.com/Aas-ee/open-webSearch/blob/main/LICENSE, checked 2026-10-19): ```text {"command": "npx", "args": ["open-websearch@latest"], "env": {"MODE": "stdio", "DEFAULT_SEARCH_ENGINE": "duckduckgo", "ALLOWED_SEARCH_ENGINES": "duckduckgo,bing,exa"}} ``` When it's better: You want keyless search without running a server. open-webSearch scrapes results from several engines (Bing, DuckDuckGo, Brave, Startpage and more) from one npx line, and fetches pages and GitHub READMEs too. Its README says it is for personal use only and that engines may block you if you search too often. ## Firecrawl self-hosted Firecrawl's open-source server in Docker Compose, firecrawl-mcp on top. Measured: v2.11.162 from the self-host guide, /v2/scrape, markdown, default settings. ```text [](https://en.wikipedia.org/wiki/Rust_(programming_language)#) Rust (programming language) =========================== * [Article](https://en.wikipedia.org/wiki/Rust_(programming_language)) * [Talk](https://en.wikipedia.org/wiki/Talk:Rust_(programming_language)) **Rust** is a [general-purpose programming language](https://en.wikipedia.org/wiki/General-purpose_programming_language … that emphasizes [performance](https://en.wikipedia.org/wiki/Computer_performance "Computer performance") , [type safety](https://en.wikipedia.org/wiki/Type_safety "Type safety") ``` Price: Free and open source (the server is AGPL-3.0). You run the Docker stack; no API key on the guide's local default. (https://github.com/firecrawl/firecrawl/blob/main/LICENSE, https://docs.firecrawl.dev/contributing/self-host, checked 2026-10-19) Install, from its own docs (https://docs.firecrawl.dev/contributing/self-host, https://github.com/firecrawl/firecrawl-mcp-server#readme, checked 2026-10-19): ```text git clone https://github.com/firecrawl/firecrawl.git && cd firecrawl git checkout v2.11.162 # .env as in the guide, then: docker compose up --build -d export FIRECRAWL_API_URL=http://localhost:3002 npx -y firecrawl-mcp ``` When it's better: You want Firecrawl's API on your own machine, without a bill. The default stack keeps scrape, crawl, map and search local, under the AGPL, and firecrawl-mcp points at it with one variable. Its guide says screenshots, page actions and the anti-bot engine are not in the default stack, and you own the upgrades. ## Questions ### Is there a free web search MCP? Yes. SearXNG with mcp-searxng and open-webSearch both search the web with no API key and no bill. mcp-server-fetch and Crawl4AI read pages but don't search. FATSEARCH reads pages for free; its search runs on your own Oxylabs or Bright Data key. What free tools still cost is context: on one Wikipedia page their default reads put 2,373 to 117,088 tokens in front of the model. ### Is there a free search API? If you host it, yes. SearXNG is a free metasearch engine with a JSON API, and mcp-searxng connects it to your agent. open-webSearch scrapes several public engines with no key, but its README says it is for personal use only and that engines may block you if you search too often. Hosted search APIs such as Tavily and Firecrawl have free monthly tiers. ### What is the best open-source data scraper? It depends on the job. To crawl a site, Crawl4AI and self-hosted Firecrawl both run a browser and return Markdown; on one Wikipedia page Crawl4AI returned 74,896 tokens and Firecrawl self-hosted 107,332. To read one page inside an agent's context, FATSEARCH used 1,384 across three reads and found the same answer. ## Related - [Web scraping MCP: every reader we measured](https://fatsearch.com/compare/) - [Crawl4AI vs Firecrawl](https://fatsearch.com/compare/crawl4ai-vs-firecrawl/) - [Benchmarks: every run, charted](https://fatsearch.com/benchmarks/) - [Method: one page, six readers](https://fatsearch.com/docs/benchmarks/#one-page-six-readers) - [Method: the hard-pages run](https://fatsearch.com/docs/benchmarks/#other-readers) By FATSEARCH · data as of 2026-10-21 · reviewed 2026-10-19 · https://fatsearch.com/compare/open-source-web-search-mcp/