Migrate from Tavily to fastCRW — Search API Migration Guide

Verdict

Migrating from Tavily to fastCRW takes about 15 minutes because fastCRW exposes a Tavily-style REST search API on POST /v1/search — most of the work is renaming parameters (max_results → limit, time_range → tbs, topic → sources). The upside beyond search: fastCRW also runs /v1/scrape, /v1/crawl, and /v1/map, which Tavily does not.

The compatibility matrix below maps every parameter, including where fastCRW ships a native equivalent under a different name.

Who this is for

• Teams whose product needs search plus scraping — Tavily is search and answer only; fastCRW consolidates search, scrape, crawl, and map on one key.
• Teams sensitive to search latency — fastCRW averaged 880 ms versus Tavily's 2000 ms on a 100-query benchmark.
• Teams that want self-hosting — Tavily is cloud-only; fastCRW is AGPL-3.0 with a bundled search backend.

The one dimension where Tavily is genuinely ahead: dedicated include_domains/exclude_domains filtering and country targeting, built directly into its search request shape. Everything else maps natively — include_answer becomes fastCRW's answer: true (self-host via your own LLM key, Cloud via managed LLM on paid plans), and Tavily's /research maps onto fastCRW's own /v1/search/research/papers endpoint (see below).

Before and after: Tavily search to fastCRW search

A typical Tavily search call:

# Before — Tavily
from tavily import TavilyClient

client = TavilyClient(api_key="tvly-YOUR_KEY")
result = client.search(
    "agentic search benchmarks",
    max_results=10,
    topic="news",
    time_range="week",
)
for item in result["results"]:
    print(item["title"], item["content"])

The fastCRW equivalent is a POST /v1/search with renamed params:

# After — fastCRW
import requests

response = requests.post(
    "https://api.fastcrw.com/v1/search",
    headers={"Authorization": "Bearer crw_live_YOUR_KEY"},
    json={
        "query": "agentic search benchmarks",
        "limit": 10,            # was max_results
        "sources": ["news"],    # was topic
        "tbs": "qdr:w",         # was time_range="week"
    },
)
for item in response.json()["data"]:
    print(item["title"], item["description"])  # content -> description

Note the response field rename: Tavily's results[].content is data[].description in fastCRW. The Tavily alternative page ships a ~50-line CrwTavilyShim adapter that absorbs these renames so a Tavily-shape call hits fastCRW unchanged.

Parameter mapping table

This table maps Tavily's search surface onto fastCRW. (Endpoint surface verified 2026-05-22; re-verify the live route list before quoting.)

Tavily endpoint / param	fastCRW equivalent	Migration note
POST /search	POST /v1/search	1 credit per query.
max_results (default 5, max 20)	limit (default 5, max 20)	Rename only.
time_range (day/week/month/year)	tbs (qdr:d/qdr:w/qdr:m/qdr:y)	Semantic match.
topic (general/news)	sources (["web"]/["news"])	Overlaps.
include_raw_content	scrapeOptions.formats	Shape differs; the adapter wires it through.
include_answer (bundled LLM)	answer: true	Self-host via your own LLM key, Cloud via managed LLM (paid plans).
results[].content	data[].description	Response field renamed.
results[].score	data[].score	Scale differs; treat as ordinal.
answer (response)	present when answer: true	Self-host via your own LLM key, Cloud via managed LLM (paid plans).
/extract (batched, ≤20 URLs)	/v1/extract (batched, ≤50 URLs)	Native multi-URL extraction; returns a per-URL results array.
/crawl	/v1/crawl	Async → job id; poll GET /v1/crawl/:id.
/map	/v1/map	URL discovery. 1 credit.
/research (async + SSE)	/v1/search/research/papers	Different shape (query+k params) — arXiv/OpenAlex/Semantic Scholar fan-out, highest ArXivQA recall of any tested tool.
MCP tools tavily-search	built-in /mcp (crw_search, crw_scrape, …)	Tool names differ.

Step-by-step migration

The numbered steps below mirror the howToSteps schema for this page.

1. Inventory your Tavily calls

Grep for Tavily usage. List search, extract, and any /research calls. Flag anything using include_domains, exclude_domains, or country — those are the params that need a decision, since they have no direct equivalent.

2. Provision a key or self-host

Sign up at fastcrw.com for a crw_live_ key — the Free tier ships 1000 one-time lifetime credits that never reset. To self-host, run the AGPL-3.0 stack; it ships a single static Rust binary plus a bundled hardened search backend.

3. Point search calls at /v1/search

Change the endpoint from Tavily's POST /search to fastCRW's POST /v1/search. Search costs 1 credit per query.

4. Rename the parameters

Apply the renames: max_results → limit, time_range → tbs (with the qdr: value mapping), topic → sources. include_raw_content becomes scrapeOptions.formats.

5. Drop in the adapter shim

Use the CrwTavilyShim adapter from the Tavily alternative page. It translates a Tavily-shape search() call into the fastCRW body and remaps the response — results[].content ← data[].description — so most call sites stay untouched.

6. Map answer, research, and domain filtering

include_answer maps to answer: true — self-host via your own LLM key, Cloud via managed LLM (paid plans). /research calls map onto /v1/search/research/papers. Drop include_domains/exclude_domains and country, or post-filter results client-side — this is the one gap with no direct equivalent.

7. Optionally adopt scrape, crawl, and map

This is the migration's payoff. Add /v1/scrape, /v1/crawl, and /v1/map where your product previously needed a second vendor. They share the same API key and credit pool as search.

What does not carry over

Be explicit with your team about this one Tavily-only feature:

• No domain filtering. include_domains, exclude_domains, and country are not supported; post-filter client-side.

Everything else maps natively: answer: true (self-host via your own LLM key, Cloud via managed LLM on paid plans), /v1/search/research/papers in place of /research, and /v1/extract accepting a urls array (up to 50 URLs per request — more than Tavily's batched extract at ≤20 URLs). Response field names and error envelopes differ slightly — results[].content → data[].description; score scale differs — since fastCRW is Tavily-style, not byte-identical.

Performance and pricing context

On a 100-query benchmark (triple-bench.ts), fastCRW search averaged 880 ms versus Tavily's 2000 ms, with 73 of 100 latency wins and 100% success. Treat this as a point-in-time snapshot on that query set, not a universal guarantee — the methodology is published and the benchmark page documents the run.

On price, fastCRW is credit-based: search 1 credit/query, scrape 1, crawl 1/page, map 1. The Free tier ships 1000 one-time lifetime credits that never reset; Hobby is $13/mo launch (5k credits) and Standard $69/mo (100k). The AGPL-3.0 self-host build is $0 in license terms. For Tavily's current rates, check tavily.com.

Related

• Tavily alternative comparison
• Migrate from Firecrawl
• Migrate from Jina Reader
• fastCRW vs Tavily benchmark
• fastCRW search docs
• fastCRW pricing