anyfetch

# Anyfetch

**Web search and web fetch for AI agents. One small binary, no API keys, and it reads the sites that refuse your agent.**

Free and open source, from the makers of [AliasMode](https://aliasmode.com/).

Agent harnesses fetch pages with a bot identity, and a large part of the web answers `403`. Anyfetch sends the request a real browser sends, so your agent gets the page.

| 97 popular sites that block AI agents | Pages read |
| --- | --- |
| **Anyfetch** | **75** |
| curl | 47 |
| Reference MCP fetch server | 41 |
| Claude Code built-in `WebFetch` | 36 |

Anyfetch read 21 sites that no other tool in the table could read. Among them: The New York Times, Reuters, Bloomberg, The Washington Post, Medium, Reddit, Stack Overflow and YouTube.

| 30 research questions, each asked twice | Answered correctly both times |
| --- | --- |
| **Agent with Anyfetch** | **30** |
| Same agent with Claude Code built-in `WebSearch` and `WebFetch` | 25 |

Ten of the questions are about a page on a site that blocks AI agents. The built-in fetch could not read any of those 10 pages. Its search found the answer in another source for 5 of them. Anyfetch read all 10. The questions were written from pages that Anyfetch can read, so this group shows what the built-in tools miss.

| One page, started fresh | Time | Peak memory |
| --- | --- | --- |
| **Anyfetch** | **0.19 s** | **17 MB** |
| Headless Chromium | 1.15 s | 544 MB |

Measured on 2026-10-11 from a cloud server, with no proxy. See [how we measured](#benchmark) and how to run it again.

## What your agent gets

- **Search with no key.** Brave, Yahoo and DuckDuckGo results, with domain and date filters, quoted phrases and paging. Specialist sources for GitHub, Stack Overflow, Hacker News, arXiv and research papers. Or your own SearXNG.
- **Search and read in one call.** Ask for the top results together with the result list, and get the parts of each page that match your query.
- **Answers, not whole pages.** Give a question with the URL, and get only the parts of the page that match it. The Python 3.15 release notes are 218,000 characters; the answer to one question about them came back in 2,200.
- **Clean Markdown.** Links, tables and code blocks stay intact. Long pages come in parts.
- **PDFs.** Papers and reports come back as text, page by page.
- **Sites that need JavaScript.** Anyfetch reads the data inside the page, and uses the site's public API or feed for Stack Overflow, Reddit, X posts, PyPI and crates.io. No browser runs. For pages that hold nothing without their scripts, it can use Lightpanda, an optional small engine.
- **News and answers.** Full articles on Reuters and Bloomberg, and the answers on Quora, from the data that these sites send with the page.
- **Browser-grade requests.** Safari's TLS, HTTP/2 and header fingerprint. A refused fetch is retried automatically, as the same browser or as a second one.
- **Cloudflare checks.** When a site insists on a JavaScript check, your own Firefox passes it once. After that, Anyfetch reads the site with plain requests.
- **Fast on repeat.** Several pages in one call, fetched at the same time. A page fetched in the last 15 minutes comes from a local copy.
- **Lightweight.** A 16 MB Rust binary. No bundled browser, no JavaScript engine, no Python, no Node.
- **Works everywhere.** A stdio MCP server for agent harnesses, and a plain CLI for everything else.

## Install

macOS and Linux:

```sh
curl -fsSL https://aliasmode.github.io/anyfetch/install.sh | sh
```

Windows, in PowerShell:

```powershell
irm https://aliasmode.github.io/anyfetch/install.ps1 | iex
```

The installer puts `anyfetch` in `~/.local/bin`. Then it connects Anyfetch to each agent harness that it finds on the machine: Claude Code, Codex, Gemini CLI, Hermes Agent, Pi, Cline, Amp, OpenClaw and Cursor. Start a new agent session, and the agent has `web_search`, `web_fetch` and `web_fetch_many`.

Did you install a harness later? Run `anyfetch setup`. It uses each harness's own command, tells you what it connected, and is safe to run again.

**Only Claude Code, on macOS or Linux?** You can install Anyfetch as a plugin instead. The plugin gets the program at its first start:

```sh
claude plugin marketplace add aliasmode/anyfetch && claude plugin install anyfetch@anyfetch
```

Inside Claude Code 2.1.275 or later, this is one step: `/plugin install anyfetch --marketplace aliasmode/anyfetch`. Use the plugin or the installer, not both, or the agent sees every tool twice.

## Connect your agent by hand

`anyfetch setup` does this for you. To do it by hand, each harness needs one command.

**Claude Code**

```sh
claude mcp add --scope user anyfetch -- anyfetch mcp
```

**Codex**

```sh
codex mcp add anyfetch -- anyfetch mcp
```

or in `~/.codex/config.toml`:

```toml
[mcp_servers.anyfetch]
command = "anyfetch"
args = ["mcp"]
```

**Hermes Agent**

```sh
hermes mcp add anyfetch --command anyfetch --args mcp
```

Hermes connects, lists the tools and asks to enable them. Answer `Y`.

**Pi**

```sh
pi mcp add anyfetch -- anyfetch mcp
```

Pi hides MCP tools behind its code mode by default. To show the tools to the model directly, set the exposure in `~/.pi/agent/mcp.json`:

```json
{
  "mcpServers": {
    "anyfetch": { "command": "anyfetch", "args": ["mcp"], "exposure": "direct" }
  }
}
```

**Gemini CLI**

```sh
gemini mcp add -s user anyfetch anyfetch mcp
```

**OpenCode** — in `~/.config/opencode/opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "anyfetch": { "type": "local", "command": ["anyfetch", "mcp"], "enabled": true }
  }
}
```

**Cursor** — in `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "anyfetch": { "command": "anyfetch", "args": ["mcp"] }
  }
}
```

**More harnesses**

| Harness | Command |
| --- | --- |
| Cline | `cline mcp add anyfetch --yes -- anyfetch mcp` |
| Amp | `amp mcp add anyfetch -- anyfetch mcp` |
| OpenClaw | `openclaw mcp add anyfetch --command anyfetch --arg mcp` |
| Goose | `goose session --with-extension "anyfetch mcp"` |
| VS Code (Copilot) | `code --add-mcp "{\"name\":\"anyfetch\",\"command\":\"anyfetch\",\"args\":[\"mcp\"]}"` |

Any other MCP client: add a stdio server with the command `anyfetch` and the argument `mcp`.

Anyfetch is in the official [MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=anyfetch) as `io.github.aliasmode/anyfetch`.

**No MCP?** Give the agent the CLI. Add this to `AGENTS.md` or the harness's instruction file:

```markdown
## Web access
- Search the web: `anyfetch search "<query>"`
- Read pages: `anyfetch fetch <url> [<url>...] --format markdown`
```

**Make it the default.** To have the agent use Anyfetch and not its built-in tools, turn the built-ins off:

- Claude Code, in `~/.claude/settings.json`: `"permissions": { "deny": ["WebFetch", "WebSearch"] }`
- Codex, in `~/.codex/config.toml`: `web_search = "disabled"`

## Use it from the command line

```sh
anyfetch search "rust async runtime comparison"
anyfetch search "tokio select" --site docs.rs --time year
anyfetch search "postgres vacuum freeze" --read 3
anyfetch search "retrieval augmented generation" --provider papers
anyfetch fetch https://stackoverflow.com/questions/231767 --format markdown
anyfetch fetch https://arxiv.org/pdf/1706.03762 --max-chars 8000 --offset 8000
anyfetch fetch https://docs.python.org/3.15/whatsnew/3.15.html --query "sampling profiler rate"
anyfetch fetch https://www.rust-lang.org/ https://go.dev/ https://ziglang.org/
```

Output is JSON by default, so scripts and agents can parse it. `--format markdown` prints only the page content.

## Tools

### `web_fetch`

| Input | Meaning |
| --- | --- |
| `url` | The page to read. |
| `query` | Optional. A question or keywords. The result has only the parts of the page that match. |
| `max_chars` | Optional. The most content characters to return. The default is 50,000, or 5,000 with a `query`. |
| `offset` | Optional. The first content character to return. Not used with a `query`. |
| `fresh` | Optional. Fetch again even if a copy from the last 15 minutes exists. |

The result has `title`, `description`, `content` (Markdown), `total_chars`, `url` (after redirects), `status` and `retrieved_at`. To read a long page in parts, call again with a higher `offset` until it reaches `total_chars`. The parts come from the local copy, so the site gets one request.

With a `query`, the page is split at its paragraphs, tables and code blocks. The parts that best match the words of the query come back in page order, under their headings, with `[...]` where parts are left out. The result then has `focused: true`. A page with no matching part comes back from its start. A second question about the same page uses the local copy.

HTML becomes Markdown. A PDF becomes text with `[Page N]` marks. JSON, plain text and XML feeds come back as they are.

### `web_fetch_many`

| Input | Meaning |
| --- | --- |
| `urls` | The pages to read. They are fetched at the same time. |
| `query` | Optional. As for `web_fetch`. Each page gives up to 5,000 characters. |
| `max_chars` | Optional. The most content characters per page. By default the pages share 50,000. |
| `fresh` | Optional. As for `web_fetch`. |

The result has `pages`: one entry per URL, in order. Each entry is the page, or its `error`.

### `web_search`

| Input | Meaning |
| --- | --- |
| `query` | The search query. Quoted phrases work. |
| `provider` | Optional. See the list below. The default is `auto`. |
| `site` | Optional. Keep results from one domain, for example `docs.rs`. |
| `time` | Optional. `day`, `week`, `month` or `year`. |
| `page` | Optional. The result page, from 1. |
| `read` | Optional. Also return, from this many top results, the parts of each page that match the query. |
| `searxng_url` | The base URL of your SearXNG instance, for the `searxng` provider. It must have JSON output on. |

Each result has `title`, `url` and `snippet`, and `content` when you se