Tavily-Style Search API — Free to Self-Host (2026)

TL;DR — pick your path before reading the matrix

This page serves three readers. If you're:

• Hunting a hosted Tavily alternative, jump to the hosted plan section. Tavily's free Researcher tier (1,000 credits/month) and PAYG ($0.008/credit) are the obvious paid options to compare against.
• Looking for OSS or self-hosted, skip to free to self-host. fastCRW is AGPL-3.0; SearXNG, OrioSearch, agent-search, and Vane are the other live OSS projects worth knowing about.
• Already happy with Tavily, the where Tavily is still the right call section is honest about that. We don't want you to switch if your workload doesn't justify it.

fastCRW Cloud (hosted, paid) and fastCRW (OSS) (AGPL-3.0, free to self-host) are different products. Above the fold this page is mostly about the OSS one — the part that's free.

At-a-glance comparison

Decision area	fastCRW (OSS)	fastCRW Cloud	Tavily
Pricing	$0 + your server	Hosted plan	Free Researcher tier (1,000 cr/mo); PAYG $0.008/credit
License	AGPL-3.0	Proprietary (managed)	Proprietary
Hosting	Self-host on Docker	Managed	Cloud-only
Search endpoint	/v1/search (Tavily-style)	/v1/search (Tavily-style)	/search
Synthesized answer	No	No	Yes (include_answer)
Domain filtering	No	No	Yes (include_domains/exclude_domains)
Batch extract	No (single URL)	No (single URL)	Yes (up to 20 URLs)
MCP server	crw_search/crw_scrape/crw_crawl/crw_map	Same	tavily-search/tavily-extract
Migration adapter	Python shim included	Same	n/a

The honest framing: Tavily ships features fastCRW doesn't (LLM-synthesized answers, domain filters, batched extract, agentic /research). fastCRW ships things Tavily doesn't (free self-hosting, MCP across crawl/map, AGPL source code). Pick the side that matches your constraint.

Free to self-host: the durable argument

The strongest reason to evaluate fastCRW is that you can run it for $0 beyond your own server. The compose stack:

git clone https://github.com/us/crw && cd crw
cp .env.example .env
docker compose up --build
# fastCRW + hardened SearXNG sidecar + Redis on :8080

What you get for $0:

• A Tavily-style /v1/search endpoint with optional Bearer auth.
• /v1/scrape, /v1/crawl, /v1/map with the same bearer-token model.
• An MCP server (crw-mcp) wired for Claude Desktop, Cursor, and Windsurf.
• A SearXNG sidecar configured with read-only rootfs, dropped Linux capabilities, no-new-privileges, memory and PID limits, and a pinned image tag. The hardening config is in the repo; you can audit it.

What you don't get:

• An external service that absorbs upstream rate limits. The SearXNG sidecar is at the mercy of Google/Bing/etc. At scale, wire in a Brave Search API key (or move to hosted).
• A managed uptime SLA. Self-hosted means you own the pager.

Read the self-hosting hardening notes →

Compatibility matrix

The single load-bearing claim on this page is Tavily-style — same concepts, different param names. Below is the abridged matrix; the full row-by-row version lives in COMPATIBILITY.md.

Search request

Surface	Tavily	fastCRW	Compatible?
Path	POST /search	POST /v1/search	adapter required
Auth	Authorization: Bearer tvly-<key>	Authorization: Bearer <key> (optional self-host)	similar shape
Result count	max_results (default 5, max 20)	limit (default 5, max 20)	rename only
Time filter	time_range (day/week/month/year)	tbs (qdr:d/qdr:w/qdr:m/qdr:y)	semantic match
Topic	topic (general/news/finance)	`sources: ["web"	"news"
Search depth	search_depth (basic/advanced/fast/ultra-fast)	none	gap
Domain filter	include_domains, exclude_domains	none	gap
Country	country (195+ codes)	none	gap
Answer synthesis	include_answer	none	gap
Raw content	include_raw_content	scrapeOptions.formats	shape differs

Search response

Field (Tavily)	Field (fastCRW)	Match?
query (echoed)	not echoed	gap
answer	n/a	gap
results[].title	data[].title	✅
results[].url	data[].url	✅
results[].content	data[].description	renamed
results[].score	data[].score	scale differs (treat as ordinal)
results[].raw_content	data[].markdown (when scrapeOptions set)	shape differs

Other endpoints

Endpoint	Tavily	fastCRW
Extract	/extract (batched, ≤20 URLs)	/v1/scrape (single URL)
Crawl	/crawl	/v1/crawl (different param names)
Map	/map	/v1/map
Research	/research (async + SSE)	not available
MCP tools	tavily-search, tavily-extract	crw_search, crw_scrape, crw_crawl, crw_map, crw_check_crawl_status

The forbidden phrase on this page is drop-in replacement. The honest phrase is Tavily-style with adapter. The next section ships the adapter.

Migration in 5 minutes — Python adapter shim

If you have existing code calling Tavily, this shim lets a Tavily-shape call hit fastCRW. Drop it in, swap your client, you're migrated.

import requests

class CrwTavilyShim:
    """Adapt Tavily-style calls to fastCRW /v1/search.

    Caveats vs real Tavily:
      - No `answer` synthesis (returns "" if include_answer is set).
      - No `include_domains` / `exclude_domains` / `country` filtering.
      - `topic="finance"` is not supported.
      - `score` is SearXNG-derived; treat as ordinal not absolute.
      - `raw_content` requires scrapeOptions; this shim wires it through.
    """
    def __init__(self, base_url: str, api_key: str | None = None):
        self.base_url = base_url.rstrip("/")
        self.headers = {"Content-Type": "application/json"}
        if api_key:
            self.headers["Authorization"] = f"Bearer {api_key}"

    def search(
        self,
        query: str,
        *,
        max_results: int = 5,
        topic: str = "general",
        time_range: str | None = None,
        include_raw_content: bool | str = False,
        **_unsupported,
    ) -> dict:
        sources = {"general": ["web"], "news": ["news"]}.get(topic, ["web"])
        body = {"query": query, "limit": max_results, "sources": sources}
        if time_range:
            tbs_map = {"day": "qdr:d", "week": "qdr:w", "month": "qdr:m", "year": "qdr:y"}
            body["tbs"] = tbs_map.get(time_range, time_range)
        if include_raw_content:
            body["scrapeOptions"] = {"formats": ["markdown"], "onlyMainContent": True}
        r = requests.post(f"{self.base_url}/v1/search", json=body, headers=self.headers)
        r.raise_for_status()
        data = r.json()["data"]
        web = data["web"] if isinstance(data, dict) and "web" in data else data
        return {
            "query": query,
            "answer": "",  # fastCRW does not synthesize answers
            "results": [
                {
                    "title": item["title"],
                    "url": item["url"],
                    "content": item.get("description", ""),
                    "score": item.get("score"),
                    "raw_content": item.get("markdown"),
                }
                for item in web
            ],
        }


# Usage:
# client = CrwTavilyShim("http://localhost:8080", api_key=None)  # self-hosted, no auth
# client = CrwTavilyShim("https://fastcrw.com/api", api_key=os.environ["FASTCRW_KEY"])
# results = client.search("agentic search benchmarks", max_results=10, topic="news")

The shim is intentionally small — under 50 lines — so you can audit and adapt it. The full version with retry, backoff, and async support lives in the docs/search reference.

Pricing math at scale

Volume	Tavily PAYG	Tavily Researcher (free)	fastCRW (OSS, your server)	fastCRW Cloud
1,000 req/mo	$8	covered (1,000 credits free)	~$5 server cost (Hetzner CX22)	included in entry plan
10,000 req/mo	$80	not covered	same server	hosted plan
100,000 req/mo	$800	not covered	~$15 server (CX42) + ops	hosted plan
1,000,000 req/mo	$8,000	not covered	~$60 server cluster + ops	enterprise

Two honest caveats:

• "$0 to self-host" is software cost. Server time, monitoring, and your hours are real costs.
• At low volumes, Tavily's free Researcher tier is unbeatable. We don't try to beat it; we beat the upgrade math at 5K–10K+ requests.

Open the hosted pricing →

License notice (AGPL-3.0)

fastCRW is licensed under AGPL-3.0. The full license text is at gnu.org/licenses/agpl-3.0.html. AGPL has specific requirements for network-deployed modifications to the licensed software — calling the API from your application is not a modification. Consult your own legal counsel for your specific deployment; we deliberately do not author license interpretation in this page.

If your organization has a hard rule against AGPL-licensed dependencies, fastCRW Cloud is the obvious path — the cloud build is a separate offering with separate terms.

Vendor consolidation note (Nebius acquisition, Feb 2026)

Nebius announced its agreement to acquire Tavily on 2026-02-10: $275M cash + up to $125M earnouts. The official Nebius release confirms Tavily continues operating under its own brand, with founder Rotem Weiss joining Nebius. The deal had not closed publicly as of May 2026.

What this means for buyers:

• Today, nothing has changed for Tavily users. Pricing, API surface, and roadmap all match pre-acquisition state.
• The risk on the table is vendor consolidation — Tavily becomes a feature of Nebius's AI cloud, not an independent service.
• If your procurement process treats consolidation as risk, the OSS fallback is exactly the question this page is built to answer.

This is not "Tavily is dying." Tavily reports ~1M developers and 3M monthly SDK downloads; the founding team is staying on. The angle is supply-chain optionality, not FUD.

Where Tavily is still the right call

If your workload looks like:

• a single-API search-and-extract product, no broader scrape/crawl/map needs,
• you actively use include_answer for LLM-synthesized responses,
• you depend on include_domains/exclude_domains filtering or country targeting,
• you batch-extract dozens of URLs at a time,
• or you want Tavily's /research agentic endpoint,

then Tavily ships features fastCRW does not, and the right move is to stay on Tavily. The Researcher tier is a real free option at low volume, MCP support is official, and the product focus is narrow on AI search.

We are not anti-Tavily. We're saying: if your needs are broader (scrape + crawl + map + self-host), or if your procurement bias is toward open source you can run yourself, fastCRW is the better-shaped tool.

Hosted plan: when you don't want to run servers

Some teams want Tavily-style endpoints, OSS-grade transparency, and a credit card instead of a Docker compose file. fastCRW Cloud is the same API surface as the OSS build, run by us, with usage-based pricing competitive with Tavily PAYG at the 10K–100K req/mo range. See the pricing page →

Recommended evaluation flow

1. Read the compatibility matrix above. Confirm none of the gaps are deal-breakers (no answer, no domain filters, no batch extract, no /research).
2. Spin up the OSS stack locally: docker compose up. Hit /v1/search with curl. Make sure the response shape works for your code.
3. Drop in the migration adapter. Swap TavilyClient for CrwTavilyShim in one staging service.
4. Decide hosted vs self-host based on volume. Below ~5K req/mo, Tavily Researcher's free tier beats both. 5K–100K, the OSS self-host or fastCRW Cloud both make sense depending on your ops appetite. Above 100K, talk to us.
5. If you want to compare against more OSS options, read open-source Tavily alternatives (covers OrioSearch, agent-search, SearXNG-direct) and self-hosted search APIs (the broader category, devops-focused).

You can also compare against adjacent paid APIs: fastCRW vs Firecrawl, fastCRW vs SerpAPI, and Tavily vs Serper for the head-to-head between the two paid search APIs.

Three calls to action

• Deploy OSS — git clone github.com/us/crw && docker compose up. Quickstart →
• View docs — endpoint reference, error codes, MCP tool schema. Search docs →
• Start hosted plan — managed, no Docker. Pricing →