Tavily vs Brave vs Exa: Free Search APIs for AI Agents

On this page
  1. Tavily vs Brave vs Exa: Free Tiers
  2. MCP Server Tool Names: Tavily vs Brave vs Exa
  3. Tavily — LLM-Ready by Design
  4. Brave — Independent Index, Watch the Rate Limit
  5. Exa — Neural and Find-Similar
  6. Head-to-Head
  7. Which One? A Quick Decision Path
  8. The "Search Router" Pattern
  9. Pairing Search With a Free LLM
  10. Frequently Asked Questions
Quick answer: For a low-cost AI-agent search tool, pick by job: Tavily (1,000 credits/month) returns LLM-ready text; Brave offers $5 in monthly credits on its paid Search plan, but requires a credit card even if you set prepay to $0; Exa ($10 monthly balance, no card) handles neural and find-similar search. Their MCP servers name the search tool 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

FeatureTavily (Free)Brave ($5 credit)Exa (Free)
Free quota1,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 limitNot published on pricing page50 queries/sec (Search plan)Not published on pricing page
Credit cardNoYes (since Feb 2026)No
ResetsMonthly$5 credit monthlyBalance resets to $10 on the 1st of each month
Index typeAggregated + own crawlIndependent crawlNeural embeddings
Content extractionYes (include_raw_content)Extra snippets + LLM context (Search plan)Yes (contents.text)
Best forRAG agents needing clean textIndependent index with monthly credits; card requiredSimilarity / 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:

ProviderMCP package / installTool namesEnv var
Tavily
tavily-ai/tavily-mcp
npx -y tavily-mcp@latest
or 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/mcp
npm 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 adds contents.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

FrameworkTavilyBraveExa
LangChain / LangGraphNativeNativeNative
CrewAINative toolCustom BaseToolNative tool
MCP serversOfficialOfficial (8 tools)Official

Which One? A Quick Decision Path

  1. An LLM needs clean, summarized text? → Tavily.
  2. 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).
  3. Research, similarity, or non-obvious sources? → Exa (neural + find_similar have no free rival).
  4. News in the last hour? → Brave or Tavily; avoid Exa.
  5. 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.