On this page
- Tavily vs Brave vs Exa: Free Tiers
- MCP Server Tool Names: Tavily vs Brave vs Exa
- Tavily — LLM-Ready by Design
- Brave — Independent Index, Watch the Rate Limit
- Exa — Neural and Find-Similar
- Head-to-Head
- Which One? A Quick Decision Path
- The "Search Router" Pattern
- Pairing Search With a Free LLM
- Frequently Asked Questions
tavily-search, brave_web_search and web_search_exa respectively.An AI agent reasons well but knows nothing about yesterday — so every framework (CrewAI, LangGraph, Aider, any MCP server) eventually hands it a search API. Google's is enterprise-only, Bing's is retiring, and SerpAPI starts at $75/month. That leaves three serious options, each with a different definition of "free" — and as of 2026, only two of them still are.
Tavily vs Brave vs Exa: Free Tiers
| Feature | Tavily (Free) | Brave ($5 credit) | Exa (Free) |
|---|---|---|---|
| Free quota | 1,000 credits/month | $5 credit/month (~1,000 queries) — no-card free tier retired Feb 2026 | $10/month (~1,400 searches at $7/1,000) |
| Rate limit | Not published on pricing page | 50 queries/sec (Search plan) | Not published on pricing page |
| Credit card | No | Yes (since Feb 2026) | No |
| Resets | Monthly | $5 credit monthly | Balance resets to $10 on the 1st of each month |
| Index type | Aggregated + own crawl | Independent crawl | Neural embeddings |
| Content extraction | Yes (include_raw_content) | Extra snippets + LLM context (Search plan) | Yes (contents.text) |
| Best for | RAG agents needing clean text | Independent index with monthly credits; card required | Similarity / research |
The short version: reach for Tavily when an LLM will read the result, Brave when you want lots of independent results cheaply, and Exa when you want results that share meaning, not just keywords.
MCP Server Tool Names: Tavily vs Brave vs Exa
All three ship an official MCP server, and the tool identifiers differ enough that a config or prompt written for one will not work with another. Checked against each provider's own GitHub repo on 2026-09-29:
| Provider | MCP package / install | Tool names | Env var |
|---|---|---|---|
| Tavily tavily-ai/tavily-mcp |
npx -y tavily-mcp@latestor remote: https://mcp.tavily.com/mcp/ |
tavily-search, tavily-extract, tavily-map, tavily-crawl |
TAVILY_API_KEY |
| Brave Search brave/brave-search-mcp-server |
npx -y @brave/brave-search-mcp-server --transport stdio |
brave_web_search, brave_local_search, brave_video_search, brave_image_search, brave_news_search, brave_summarizer, brave_place_search, brave_llm_context |
BRAVE_API_KEY |
| Exa exa-labs/exa-mcp-server |
Remote: https://mcp.exa.ai/mcpnpm package: exa-mcp-server |
Default: web_search_exa, web_fetch_exa. Opt-in via ?tools=: web_search_advanced_exa, agent_run |
EXA_API_KEY |
Three naming conventions for the same idea: Tavily uses provider-verb with a hyphen, Brave uses provider_verb with an underscore, and Exa puts the provider last (web_search_exa). If an agent reports an unknown tool, this is usually why. None of them is literally called web_search or search_results — those are names agent frameworks give their own built-in tools, so map them to the provider's name explicitly.
Brave's server is the broadest — eight tools covering news, images, video and local results — and you can trim it per deployment with BRAVE_MCP_ENABLED_TOOLS / BRAVE_MCP_DISABLED_TOOLS (space-separated lists), which helps when a model keeps reaching for image search during a text task. brave_llm_context returns context shaped for an LLM rather than a raw result list. Exa's server exposes only two tools unless you append them to the URL, e.g. https://mcp.exa.ai/mcp?tools=web_search_advanced_exa.
Which to wire into an agent: start with Tavily's tavily-search + tavily-extract if you want no card and clean text; add Exa's web_search_exa for research and semantic lookups; pick Brave when you need news, image or local results from an independent index and are fine adding a card.
Tavily — LLM-Ready by Design
Tavily is a search API built for LLMs: instead of ten blue links, one call returns ranked URLs plus a clean, model-ready answer extracted from the top results. That cuts both tokens (one summary instead of ten noisy HTML pages) and latency (one HTTP call instead of a search plus ten fetches). It's the default search tool in LangChain and the recommended one in the CrewAI docs.
The free tier: 1,000 credits/month (1 credit = 1 basic search; search_depth="advanced" costs 2), no credit card, full API access. Tavily doesn't run a Google-scale crawler — it aggregates upstream sources plus a curated crawl, then re-ranks for your query. The ranking is the product, not the index size.
from tavily import TavilyClient
client = TavilyClient(api_key="tvly-YOUR_KEY")
response = client.search(
query="major Claude 4.7 release notes",
search_depth="basic", # "advanced" = deeper crawl, 2 credits
max_results=5,
include_answer=True, # LLM-generated summary
include_raw_content=False, # True = full extracted page text
)
print(response["answer"])
CrewAI ships the wrapper, so dropping it into an agent is one line — tools=[TavilySearchTool(api_key="tvly-YOUR_KEY")]. For the agent side, see our free CrewAI guide.
Brave — Independent Index, Watch the Rate Limit
Brave Search API serves ~30 billion pages from its own crawler — not Bing, not Google. That independence is the pitch: if you're building a Perplexity-style product where the index is the moat, you need one you control or license cheaply. It also exposes web, news, video, image, and suggest endpoints under one key.
Brave's current billing FAQ says there is no standalone free API plan. Each plan includes $5 in credits that renew monthly, worth about 1,000 queries on the Search plan. To use those credits without adding prepaid funds, enter a credit card and set prepay to $0; Brave may place a refundable $0 or $1 verification hold. Usage beyond the credit bills at $5 per 1,000 Search requests unless you keep spending disabled. The Search plan allows 50 queries/sec and includes extra snippets and LLM context. The distinction for a $0 budget is the required card, not an upfront payment.
import time, requests
from collections import deque
class BraveSearch:
def __init__(self, token, rps=1):
self.token = token
self.min_interval = 1.0 / rps
self.calls = deque()
def _throttle(self):
now = time.time()
while self.calls and now - self.calls[0] > 1.0:
self.calls.popleft()
if self.calls:
time.sleep(self.min_interval - (now - self.calls[-1]))
self.calls.append(time.time())
def search(self, q, count=10):
self._throttle()
r = requests.get(
"https://api.search.brave.com/res/v1/web/search",
headers={"Accept": "application/json", "X-Subscription-Token": self.token},
params={"q": q, "count": count}, timeout=20,
)
r.raise_for_status()
return r.json()
Exa — Neural and Find-Similar
Exa (formerly Metaphor) is a semantic engine: it embeds your query and the indexed web into the same space and returns the closest pages by meaning, even with zero shared vocabulary. That unlocks queries with no good keywords ("articles by an ex-OpenAI person now in longevity research") and a unique find_similar endpoint that returns pages semantically nearest to any URL you supply. It's the wrong tool for last-hour breaking news, since the neural index lags real time.
The free path is different: a $10 free balance that resets to $10 on the first of every month, with no payment method required, plus a one-time $10 bonus for completing onboarding in the dashboard. Exa's pricing page lists Fast/Auto search at $7 per 1,000 requests and Instant search at $4 per 1,000 (rechecked 2026-09-29), so the monthly $10 is roughly 1,400 standard searches or up to 2,500 Instant ones. Page contents cost $1 per 1,000 pages. (Earlier versions of this article described a $20 sign-up credit, and before that a one-time $10 at $5 per 1,000 calls — Exa has changed the terms more than once, so check the pricing page before you budget.)
from exa_py import Exa
exa = Exa(api_key="YOUR_KEY")
result = exa.search_and_contents(
"research papers on RAG evaluation",
type="neural", num_results=5,
text={"max_characters": 2000}, # cleaned page text
)
for r in result.results:
print(r.title, "-", r.url)
# Given any URL, return semantically similar pages:
similar = exa.find_similar_and_contents("https://example.com/post", num_results=5, text=True)
Head-to-Head
- LLM-ready output: Tavily wins by design (
include_answer+include_raw_content, no extra credits). Exa ties on extraction and addscontents.summary. Brave's Search plan returns snippets plus an LLM-context output rather than a summarized answer. - Latency (p50, no extraction — rough typical ranges, not measured by us): Brave ~250–400 ms is fastest; Tavily basic and Exa neural ~400–800 ms; Tavily advanced ~1.5–3 s (only worth it when quality justifies the wait).
- Freshness: Brave leads (crawler updates within hours; dedicated news endpoint). Tavily inherits upstream freshness (1–6 hrs). Exa lags on very recent content unless you force
livecrawl="always". - Real quota math: an agent doing 5 searches × 20 daily users = ~3,000/month, past every free allowance. Tavily's free tier covers ~6 users/day, Brave's $5 monthly credit about the same (~1,000 queries), Exa's monthly $10 is roughly 1,400 searches. Beyond hobby scale you'll pay — pick by access pattern.
Framework Support
| Framework | Tavily | Brave | Exa |
|---|---|---|---|
| LangChain / LangGraph | Native | Native | Native |
| CrewAI | Native tool | Custom BaseTool | Native tool |
| MCP servers | Official | Official (8 tools) | Official |
Which One? A Quick Decision Path
- An LLM needs clean, summarized text? → Tavily.
- High-volume cheap search on an independent index, extraction done yourself? → Brave (add a card; $5 per 1,000 requests after the $5 monthly credit).
- Research, similarity, or non-obvious sources? → Exa (neural +
find_similarhave no free rival). - News in the last hour? → Brave or Tavily; avoid Exa.
- Just prototyping and want one call that works? → Tavily (easiest, cleanest, biggest monthly quota).
The "Search Router" Pattern
For serious systems, a single provider is a brittle dependency. Wrap all three behind one internal tool that routes by query intent — the agent picks the intent, the router uses whichever provider is best and still has free quota:
def smart_search(query, intent="general"):
# intent: 'news' | 'research' | 'similar' | 'general'
if intent == "news": # Brave — freshest index
return brave.search(query, count=5)
if intent == "research": # Exa neural — semantic matching
return exa.search_and_contents(query, type="neural", num_results=5,
text={"max_characters": 1500})
if intent == "similar": # Exa find-similar (query is a URL)
return exa.find_similar_and_contents(query, num_results=5, text=True)
# default: Tavily — LLM-optimized general retrieval
return tavily.search(query=query, search_depth="basic",
include_answer=True, max_results=5)
Pair this with a cache keyed by (query, intent) — TTL 1 hour for general, 15 min for news, 24 hours for stable reference — and your real search bill stays near zero. Aggressive caching saves more credit than any other optimization.
Pairing Search With a Free LLM
Search APIs feed text to an LLM that writes the answer. A low-cost stack can pair Tavily or Exa search with a free LLM tier from Groq or Gemini, orchestrated by CrewAI or LangGraph and traced with Langfuse. Whether hobby use costs $0 depends on current limits across all services.
If the orchestrator is an agent harness rather than your own code, check which backend it actually calls before counting on a free tier: DeepSeek Harness registers web_search as a built-in tool but defaults it to a paid provider, and fails silently when the balance is zero.
Frequently Asked Questions
Can I use these for commercial products?
Yes — all three allow commercial use on every tier, including free. Check each ToS for redistribution limits (you generally can't resell raw results as a competing search engine, but can use them in any end-product feature).
Does Google offer a free search API in 2026?
Not a general one. Custom Search JSON API gives 100 queries/day but only over a preset list of domains; Vertex AI Search is enterprise-only.
Which works best in MCP setups?
All three are official now. Tavily's exposes tavily-search, tavily-extract, tavily-map and tavily-crawl; Exa's exposes web_search_exa and web_fetch_exa by default, with web_search_advanced_exa and agent_run opt-in; Brave's is the broadest with eight tools including brave_llm_context, which returns LLM-shaped context rather than a result list. Brave used to be community-only — that changed, and its server is now the most configurable of the three.
Is there a single "best free search API"?
No — Tavily for LLM-consumed retrieval, Brave for independent high-volume, Exa for semantic/find-similar. When you can't pick, use the router pattern above.
Related Reads
- MCP (Model Context Protocol): Connect AI Agents to Any Tool or API — how all three providers ship MCP servers
- CrewAI vs AutoGPT vs LangGraph: Free Agent Frameworks — choosing the orchestrator that consumes your search results
- Langfuse: Free Open-Source LLM Observability — trace every search call and LLM call your agent makes
- Groq Free API Tested: Speed, Rate Limits and What You Can Build — the LLM half of the free agent stack