@aliasmode/anyfetch 0.0.0-stage → 0.7.1

package/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     https://www.apache.org/licenses/LICENSE-2.0
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,3 +1,368 @@
-# Temporary Holding Version
+# Anyfetch
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**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.
+
+**Do you have Node.js?** Then no install is needed. Give your MCP client this server, and `npx` gets the program for your platform:
+
+```json
+{
+  "mcpServers": {
+    "anyfetch": { "command": "npx", "args": ["-y", "@aliasmode/anyfetch", "mcp"] }
+  }
+}
+```
+
+**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`, and on npm as [`@aliasmode/anyfetch`](https://www.npmjs.com/package/@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 set `read`.
+
+| Provider | Source |
+| --- | --- |
+| `auto` | Brave, then Yahoo, then DuckDuckGo: each one when the one before gives no results. |
+| `brave` | Brave Search. About 20 results per page. |
+| `yahoo` | Yahoo Search. 7 results per page. No `year` filter. |
+| `duckduckgo` | DuckDuckGo. First page only. |
+| `searxng` | Your own SearXNG instance. |
+| `github` | GitHub repositories, with stars and language. |
+| `stackoverflow` | Stack Overflow questions, with score and answer count. |
+| `hackernews` | Hacker News stories, with points and the discussion link. |
+| `arxiv` | arXiv papers, with abstracts. |
+| `papers` | Research papers from OpenAlex, with citation counts and open-access links. |
+
+`site`, `time` and quoted phrases apply to the web engines. The specialist sources are free public APIs with their own request limits.
+
+### Errors
+
+A failed call returns an `error` object with a `code` the agent can act on:
+
+| Code | Meaning |
+| --- | --- |
+| `challenge_required` | The site answered with a bot challenge that needs a browser. |
+| `http_error` | The site refused the request. `status` has the HTTP code. |
+| `rate_limited` | The site asked to slow down. `retry_after` has the wait, when given. |
+| `timeout` | The site did not answer within 30 seconds. |
+| `unsupported_content` | The URL is not text or a PDF (an image, for example). |
+| `extraction_failed` | The page has no readable content. A scanned PDF has no text. |
+
+## Cloudflare checks
+
+Some sites answer every first request with a JavaScript check. Anyfetch handles it in two steps:
+
+1. Your own Firefox passes the check once. It runs hidden, with a throwaway profile, for a few seconds.
+2. Anyfetch saves the clearance for that site and goes back to plain requests. On Medium, one pass is good for a year.
+
+In our test, the first page of such a site took about 5 seconds and the next one under 2 seconds.
+
+This needs Firefox, or a Firefox-based browser, on the machine. Without one, nothing changes: the fetch returns `challenge_required`.
+
+| Setting | Effect |
+| --- | --- |
+| `ANYFETCH_BROWSER=off` | Never start a browser. |
+| `ANYFETCH_BROWSER=/path/to/browser` | Use this Firefox-based browser. |
+
+For an MCP server, set the variable in the server entry. In Claude Code:
+
+```sh
+claude mcp add --scope user anyfetch -e ANYFETCH_BROWSER=off -- anyfetch mcp
+```
+
+Notes:
+
+- Tested on Linux. On Windows, and for a snap-packaged Firefox (the Ubuntu default), the browser is used only when `ANYFETCH_BROWSER` names it.
+- A clearance belongs to the address that earned it, so the browser is not used together with a proxy.
+- Saved clearances are in `~/.config/anyfetch/clearance/`. Delete a file to forget a site.
+
+## Pages that need their scripts
+
+Most pages give Anyfetch their text without JavaScript: it is in the HTML, in the page's data, or behind a public API. A few hold nothing until their scripts run. MSN, Spotify and Airbnb are examples. For those, Anyfetch can use [Lightpanda](https://github.com/lightpanda-io/browser), a small headless engine without a full browser.
+
+Lightpanda is optional and separate. Install it from its README, put `lightpanda` on your `PATH`, and Anyfetch uses it for the pages that need it. In our test, MSN went from no content to 154,000 characters in 12 seconds, and Spotify from no content to 23,000 characters in 3 seconds. Pages that already work are not rendered, so they stay fast.
+
+| Setting | Effect |
+| --- | --- |
+| `ANYFETCH_RENDERER=off` | Never start the renderer. |
+| `ANYFETCH_RENDERER=/path/to/lightpanda` | Use this program. |
+
+Notes:
+
+- Lightpanda makes its own requests. It is not used together with a proxy, and a site with a bot check can refuse it.
+- A rendered application page, such as a feed or a listing, comes back as the whole page in Markdown.
+
+## Use a proxy
+
+Some sites refuse cloud server addresses whatever the request looks like. If your agent runs on a server, send Anyfetch through a residential proxy. Put one line in `~/.config/anyfetch/proxy`:
+
+```
+host:port:username:password
+```
+
+Anyfetch then sends every search and fetch through that HTTP proxy. The file holds the password in plain text, so keep it private: `chmod 600 ~/.config/anyfetch/proxy`. Delete the file to go direct again.
+
+Need a proxy? [NobleProxy](https://nobleproxy.com/?utm_source=anyfetch&utm_medium=readme&utm_campaign=anyfetch) is our own service: static residential IPs that only you use, with unlimited bandwidth and HTTP support.
+
+## What it does not do
+
+Anyfetch itself does not run JavaScript, solve CAPTCHAs or log in. A page that shows its content only after its scripts run, with no data inside the HTML and no public API, returns its title and description unless Lightpanda is installed. It reads what a site sends to a first-time visitor. A page that needs a CAPTCHA, an account or a subscription to load stays closed, and Anyfetch says so with an error code.
+
+Does your agent need a real browser, with logins and saved sessions? Use [AliasMode](https://aliasmode.com/use-cases/ai-agents/). It is our free, open-source antidetect browser, and it has its own MCP server for agents.
+
+## Benchmark
+
+The numbers at the top come from two scripts and one question set in [`bench/`](bench).
+
+- **Pages read.** `bench/bench.py` reads each of the 97 sites in [`bench/sites.txt`](bench/sites.txt) once with each tool. A page counts as read when the tool returns at least 500 characters of text and the text is not a bot check. The same rule is applied to every tool. Anyfetch ran three times and read 73, 76 and 75 pages; the table shows the middle run. Claude Code's `WebFetch` cannot be scripted, so an agent called it once per site and recorded if real content came back.
+- **Time and memory.** `bench/speed.py` reads 10 pages with each program, started fresh for every page, and reports the median.
+
+- **Research questions.** [`bench/tasks.json`](bench/tasks.json) has 30 questions. Each has one exact answer and the sentence on the source page that proves it. The pages are from July to October 2026, so a model cannot answer from memory. A Claude Sonnet agent answered the questions with Anyfetch only, and again with the built-in `WebSearch` and `WebFetch` of Claude Code only. The instructions were the same: at most 8 web calls for each question, and the answer `UNKNOWN` when the tools do not give it. Anyfetch ran with no proxy, no Firefox and no Lightpanda. Each tool ran twice, and a question counts when both runs are correct.
+
+| Question group | Anyfetch | Built-in tools |
+| --- | --- | --- |
+| A page on a site that blocks AI agents | 10 of 10 | 5 of 10 |
+| A page on an open site | 10 of 10 | 10 of 10 |
+| No URL: search first, then read | 10 of 10 | 10 of 10 |
+
+In each single run the built-in tools answered 26 questions, but not the same 26. Three things to know about this test. The question writer used Anyfetch to check each answer, so the first group has only pages that Anyfetch can read. Four more sites on the writer's list (Reuters, Bloomberg, Financial Times and Quora) have no question, because it could not read an article page there. The site test above reads the home page of Reuters and Bloomberg, which Anyfetch can read. Since version 0.7.0, Anyfetch also reads article pages on Reuters and Bloomberg and the answers on Quora. The Financial Times needs a subscription. One Anyfetch test agent stopped after its first question, so its 5 questions were run again. Every answer is in [`bench/results/tasks.tsv`](bench/results/tasks.tsv).
+
+The per-site results are in [`bench/results/`](bench/results). Sites change their rules often, and results differ between networks, so run it yourself:
+
+```sh
+python3 bench/bench.py anyfetch curl
+pip install mcp-server-fetch && python3 bench/bench.py reference
+python3 bench/speed.py /path/to/chromium
+```
+
+## Build from source
+
+You need Rust 1.98, `cmake` and `clang` (the TLS library is BoringSSL). On Windows you also need NASM.
+
+```sh
+cargo install --git https://github.com/aliasmode/anyfetch
+```
+
+## License
+
+Apache-2.0

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@aliasmode/anyfetch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.1",
+  "description": "Web search and web fetch for AI agents, with no API keys. Reads the sites that refuse AI agents.",
+  "keywords": ["mcp", "mcp-server", "web-search", "web-fetch", "ai-agents", "claude-code", "codex", "cursor"],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/aliasmode/anyfetch",
+  "repository": { "type": "git", "url": "git+https://github.com/aliasmode/anyfetch.git" },
+  "mcpName": "io.github.aliasmode/anyfetch",
+  "bin": { "anyfetch": "run.js" },
+  "files": ["run.js"],
+  "engines": { "node": ">=16" },
+  "optionalDependencies": {
+    "@aliasmode/anyfetch-darwin-arm64": "0.7.1",
+    "@aliasmode/anyfetch-darwin-x64": "0.7.1",
+    "@aliasmode/anyfetch-linux-arm64": "0.7.1",
+    "@aliasmode/anyfetch-linux-x64": "0.7.1",
+    "@aliasmode/anyfetch-win32-x64": "0.7.1"
+  }
+}

package/run.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Starts Anyfetch. npm installs the package that holds the program for this platform; this
+// file finds it and passes the arguments on.
+const { spawnSync } = require('node:child_process');
+
+const platform = `${process.platform}-${process.arch}`;
+const file = process.platform === 'win32' ? 'anyfetch.exe' : 'anyfetch';
+let program;
+try {
+  program = require.resolve(`@aliasmode/anyfetch-${platform}/${file}`);
+} catch {
+  console.error(`Anyfetch has no npm package for ${platform}. See https://github.com/aliasmode/anyfetch#install`);
+  process.exit(1);
+}
+const result = spawnSync(program, process.argv.slice(2), { stdio: 'inherit' });
+if (result.error) {
+  console.error(`Anyfetch could not start: ${result.error.message}`);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);