Ransack

Give your AI the web.

Search, fetch, and verify behind one flat-rate key. The fetch ladder gets pages plain requests can't. Receipts, not verdicts.

{"mcpServers": {
  "ransack": {
    "url": "https://ransack.tools/mcp",
    "headers": {
      "Authorization": "Bearer your_key_here"
    },
    "type": "streamable-http"
  }
}
}

Works with Claude Desktop · Cursor · Cline · Windsurf · Pi · OpenCode

Every tool. One key.

Pick a tool. See the call, the real response, and what it costs your context window.

searchLive

Request

Response

Live badge = runs against the real API right now. Recorded = real captured response, frozen.

One page. 2,181 tokens → 253.

Ransack returns the extracted facts, not the raw page. Toggle to see what your agent actually receives.

Raw page dump

2,181 tokens

Ransack fetch

253 tokens

88% less context for the same facts - room for 8× more pages in the same window.

{
  "url": "https://acme.com/dgx-spark",
  "title": "DGX Spark - Product Page",
  "facts": {
    "gpu": "GB10 Grace Blackwell",
    "memory": "128 GB unified",
    "power": "150W max TDP (240W PSU included)",
    "preorders": "open"
  },
  "extracted_from": "specs section + JSON-LD schema",
  "stripped": "nav, scripts, styles, cookie banner,
               footer, marketing sections (14)",
  "source_verified": true
}

Numbers shown: 2,181 → 253 tokens on a real product-page fetch (the killer receipt). Swap in the live endpoint on deploy.

Pages plain requests can't touch.

The fetch ladder: Ransack climbs rung by rung until the page yields. Watch it run.

1

Plain requests

Default urllib / requests GET, no headers, no JS.

2

Browser-grade headers

Realistic UA, Accept-Language, sec-fetch hints.

3

Headless render

Full browser render, JS executed, layout settled.

4

Extraction to markdown

Boilerplate stripped; facts as clean markdown.

Every rung cached per URL+day. Your agent sees the page or an honest failure - never a hallucinated summary.

Point it at a page, or ask it a question.

Fetch a page

Give it a URL and it returns the page itself, rendered and extracted to markdown. No model in the path, no summary snippet.

Research a question

Search iteratively from your agent: query, read, reformulate, search again, then cite what you used. (Our one-shot research tool was retired 2026-09-20: measured against a no-search control, it underperformed on multi-hop accuracy. See the bench repo for the receipts.)

Search the web

Metasearch across engines when you don't have a URL. It surfaces links for you to fetch; it does not reconcile conflicts for you.

Know your source? Fetch it. Need a cited answer? Search iteratively from your agent and cite what you used.

Benchmarked, not vibed.

Ransack takes an agent from 46% to 74.5% on the same 200-question test. Answers graded on whether the verified fact shows up:

46%the agent alone, no search

74.5%the agent + Ransack

92.5%an answer engine like Perplexity Sonar: they write the answer, Ransack hands your agent the sources (full table at the link)

Eight providers, one harness, judged, losses included. Re-run it yourself: ransack.tools/versus · github.com/chancewalker165-dot/Ransack-bench

Start free, no card

Trial

$0

14 days · 50 calls/day

Get a free key

Paid

$15/mo

500 calls/day. Rate limits may still apply.

Start free, upgrade in-app

Already have a key? Sign in to upgrade

No credit card to start. Paid is $15/month, flat: 500 calls/day, 120 requests/min, every tool. That is $1 per 1,000 calls at full use. Rate limits may still apply.

Questions, answered honestly.

Why use ransack vs other search tools? Isn't this just Firecrawl?

No. Firecrawl is a fetch-and-convert layer: you give it a URL, it returns clean markdown. If you already know the URL, Firecrawl is the right tool (so is ransack's fetch mode).

Ransack is the layer before and after the fetch:

• Before: an engine fanout (Serper, Brave, DDG, Wikipedia, arXiv, plus keyless discovery engines) that finds the URLs in the first place. You don't hand ransack a URL, you hand it a question.
• After: a fetch ladder that tries every extractor and fallback (curl_cffi, Lightpanda, Jina, Google Cache, academic-mirror resolvers) until one wins, then returns clean markdown. Firecrawl is one fetch; ransack's ladder is every fetch stacked.
• The blackbox model: Six simple MCP tools. The engine fanout, fetch ladder, and routing burn through internally until a clean result comes out.

When to use each: know the URL and want markdown, use fetch. Have a question and want a cited answer, use search and let your agent iterate and cite. Want every angle on a host (DNS, CT logs, sitemaps, archives), use hosts mode. Firecrawl has no equivalent of any of that.

What does it cost after the trial, and what are the limits?

Trial is free for 14 days at 50 calls/day, no card. Paid is $15/month flat at 500 calls/day, and every tool is included: no per-tool pricing and no credit arithmetic.

On top of the daily cap there is a per-minute pacing limit (120/min paid, 60/min on trial) so one agent cannot starve everything else on the key. Every response reports your remaining headroom, and when you do trip it the -32029 error carries a retry_after_s you can honor.

Past the cap, calls fail fast with the reason attached. Nothing is silently dropped or quietly downgraded.

Do you log my queries or the pages you fetch?

Search and fetch are passthrough by default: the answer comes back and nothing about your query is kept. Four features do store content, and the privacy page names them precisely: research reports (so get_report can return them), the shared transcript and page caches, and the per-key semantic memory index.

Always stored: your email address (signup verification and account identification) and per-tool call counts per key (rate limiting and cost tracking). Signup IPs are stored as a salted one-way hash; new rows since 17 September 2026 hold only the hash, and the privacy page states plainly that some legacy rows could still hold the raw address.

The full detail, including the exceptions, is on the privacy page.

Does ransack run proxies?

No. The pipeline is designed to work without an IP pool. Anti-bot handling comes from browser-TLS impersonation, headless browser tiers, and degraded-content fallbacks (Google Cache, RSS/Atom feeds, Jina). Proxied fetching exists only as optional paid vendor tiers (e.g. Nimble), whose keys are not required for the pipeline to work.

Does it search for the answer, or crawl and scrape links?

It is wired into MCP, so your agent decides. Search surfaces candidate URLs when you don't know the source; fetch returns a known page as clean markdown; for a cited answer, your agent runs search iteratively and cites what it used. Know your source? Fetch it. Need a cited answer? Iterate search. Search is the starting point, not the fallback.

What happens when a page cannot be read?

Fetch tries a stack of methods before giving up: plain HTTP, TLS-impersonated fetches, a headless browser tier for client-rendered pages, and archive or cache fallbacks. If every one fails you get an explicit failure, not a guessed summary.

Known walls, stated plainly:

• TikTok extraction fails across every method we tried.
• Amazon and Walmart product pages reject a plain fetch. Use shop mode with an ASIN or product URL, which routes around the wall through tolerated sources and labels them as such.
• Hard paywalls are not bypassed. Treat a paywalled domain as unreachable rather than expecting a workaround.
• Dead pages report their HTTP status instead of returning a soft 404 shell as content.

How can I benchmark it myself?

How we grade: same questions for every provider, answers judged on whether the verified fact appears. Full method and tables: ransack.tools/versus. Unclear on a mode or parameter? Call ransack with mode=help.