Search the web.Skip the API keys.

qany queries 14 public sources, fuses their rankings, and reads pages as clean text. Use it from the CLI, over HTTP, or as an MCP server.

bun add -g @qexle/qany
Open source, MIT Bun 1.4.2 No per-query bill
qany search 14 sources
bun htmlrewriter
01

HTMLRewriter | Bun Docs

bun.com/docs/runtime/html-rewriter

HTMLRewriter transforms HTML documents with CSS selectors.

bun.com
3 of 10 results 2.2s no API keys

Sample output from a real run. Query: bun htmlrewriter.

01

One query, fourteen sources, one ranked list.

qany runs your query against public search, news, code, package, and paper indexes. It removes duplicate URLs, fuses the rankings with Reciprocal Rank Fusion, and adjusts the order with query overlap, source intent, and what you have read before.

No keys.

Free, with no account. qany calls endpoints that already answer browsers.

Fourteen sources.

DuckDuckGo, Brave, Bing, Bing News, Mwmbl, Right Dao, Hacker News, Wikipedia, MDN, Stack Overflow, GitHub, npm, arXiv, and OpenAlex.

Three surfaces.

The same binary runs as a CLI, an HTTP API, and an MCP server for Claude Code, OpenCode, Claude Desktop, and other clients.

Readable pages.

qany fetch extracts readable text, falls back to the Wayback Machine, and adds what it reads to a local BM25 corpus.

When not to use it. qany is a poor fit if you need sub-second latency or an SLA, if you run high query volume or pool IPs, if you need semantic search over a curated index, or if you need compliance guarantees. A paid API will beat qany on vague or invented-word queries.

02

Three commands to a search.

qany runs on Bun 1.4.2, and the build and the test suite target that version.

01

Install the Bun runtime.

Linux needs unzip. qany runs on macOS and Linux.

shell
curl -fsSL https://bun.com/install | bash
02

Install qany.

One command, straight from npm. The package ships ready to run.

shell
bun add -g @qexle/qany
03

Run a search.

The first run populates the cache. Later runs reuse it for 10 minutes.

shell
qany search "bun htmlrewriter"
03

Six commands, one binary.

The CLI prints three lines per result. Pass --json when another program is reading.

search <query>

Search 14 public sources and rank the merged results.

8 results, max 20
more <url>

Find pages like a URL you liked. qany seeds a web search with the page's distinctive terms.

8 results
recall <query>

Search only pages qany has read on this machine.

8 results
fetch <url>

Read a page as text, with a Wayback Machine fallback.

20,000 char cap
serve

Run the HTTP API on localhost.

port 8787
mcp

Run the MCP server over stdio.

stdio
-n, --num <n>How many answers come back. The default is 8, the ceiling is 20.
--jsonPrint one line of JSON.
--no-cacheSkip the search cache.
--rerankVerify result pages and rank by page evidence. Question-shaped queries do this automatically.
--max-chars <n>Page text cap for fetch. Default 20,000.
-p, --port <n>Port for serve. Default 8787.
shell
qany search "sqlite fts5 bm25" -n 5
qany more https://bun.com/docs/runtime/html-rewriter
qany fetch https://bun.com/docs/runtime --max-chars 4000
qany serve -p 8787

Question-shaped searches rerank automatically. When every engine returns nothing, qany retries once with DuckDuckGo's autocomplete suggestion. Set QANY_CACHE_DIR to move the cache, QANY_NO_CACHE=1 to disable it, and QANY_NO_LEARN=1 to stop recording pages in the local corpus.

04

Point your agent at it.

qany speaks MCP over stdio. It also serves a local HTTP API. There is no hosted account and no token exchange.

shell
claude mcp add --transport stdio qany -- bunx @qexle/qany@0.3.0 mcp

Add --scope user to enable qany for all your projects, or --scope project to write .mcp.json into the current project. The default scope covers this project only.

.mcp.json
{
  "mcpServers": {
    "qany": {
      "command": "bunx",
      "args": ["@qexle/qany@0.3.0", "mcp"]
    }
  }
}

Any MCP client. Spawn bunx @qexle/qany@0.3.0 mcp and speak newline-delimited JSON-RPC 2.0 on stdin and stdout. qany implements tools/list, tools/call for search, more, recall, and fetch, server/discover for MCP 2026-07-28, and the legacy initialize handshake.

05

A retrieval system with its own ranking.

qany runs fourteen engines and ranks the merged result itself, with Reciprocal Rank Fusion, a relevance vote and a freshness tie-break.

Web 05

  • DuckDuckGo
  • Brave
  • Bing
  • Mwmbl
  • Right Dao

News & community 03

  • Bing News
  • Hacker News
  • Wikipedia

Docs & code 04

  • MDN
  • Stack Overflow
  • GitHub
  • npm

Papers 02

  • arXiv
  • OpenAlex

Fuse the rankings.

qany dedupes by normalized URL and applies Reciprocal Rank Fusion. Query overlap, local corpus reads, domain trust, and query intent adjust the final order. The rarest word in the query carries the most weight.

Guard the edges.

If an engine's top three results share no word of three or more characters with the query, qany drops that engine's set. The guard catches challenge pages that masquerade as results.

Read the question twice.

Question-shaped queries split into up to three reading angles. qany fetches the top pages, reorders them by page evidence, then searches once more for vocabulary the query lacks.

Stay polite.

qany serializes requests per host, waits between calls, and retries with jittered backoff. DuckDuckGo and Brave get benched for 10 minutes after a challenge. The bench survives restarts.

Remember locally.

Every page qany reads joins a BM25 index capped at 600 pages. Later searches read from the corpus, so your reading history can move a result.

Fetch with a fallback.

qany extracts readable text and falls back to the Wayback Machine or cache. The (direct), (wayback), or (cache) tag tells you which route answered.

Add a source.

Implement the Engine interface, add the engine to the list in src/search.ts, and build the parser against a saved fixture. src/engines.ts has 14 worked examples.

src/types.ts
export interface Engine {
  name: string;
  minIntervalMs: number;
  search(query: string, num: number): Promise<SearchResult[]>;
}
06

The honest part.

qany is free because it reads public endpoints. That trade shows up in four places.

Throttling.

DuckDuckGo and Brave sometimes serve challenge pages. qany benches the challenged engine, serves a stale cache entry when it has one, and falls back to the Wayback Machine when a page fails. GitHub allows 10 repository searches a minute per IP.

One machine.

Run qany from one machine. Don't pool IPs or put it behind a large shared service. The endpoints will notice, and the cooldowns will get longer.

Privacy.

Queries go to public search engines. The cache and reading corpus stay in ~/.cache/qany. There is no qany account and no qany server in the middle.

Version 0.3.0.

Command and tool names can change until 1.0.

Read the source, then run a search.

qany is MIT-licensed and installs from npm. If it saves you an API bill, tell someone.

Open npm