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

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.

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.

Watch the pricing change first: Brave retired its no-card free tier in February 2026. The old "Data for Free" plan (2,000 queries/month, no card, 1 query/sec) is closed to new signups — existing subscribers keep it, but new users now land on metered billing: $5 of free credit each month (~1,000 queries), a credit card required up front, and no spending cap — overages bill automatically at roughly $0.003–$0.005 per query. Web results are still snippets only; extracted page bodies come from the higher Data for AI tier at $5 per 1,000 queries — the cheapest search-plus-extraction on the market, but no longer a free on-ramp. Metered plans lift the old 1 query/sec cap (Brave documents up to 50 req/sec on paid tiers), but a token bucket is still worth keeping — here it protects your bill, not just your rate limit.

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: $20 in credits on sign-up plus $10 more every month, with no payment method required. Exa's pricing page listed search at $7 per 1,000 requests when we rechecked it on 2026-09-18, so the recurring $10 is roughly 1,400 searches a month, with full feature access. (An earlier version of this article described the credit as a one-time $10 at $5 per 1,000 calls — Exa has since changed both figures.)

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 cheaper tier is snippets only — extraction is a paid add-on.
• Latency (p50, no extraction): 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

MCP Tool Names for Each Provider

All three ship an MCP server, and the tool identifiers differ enough that a config copied from one will not work with another. Verified against each provider's own repo on 2026-08-31:

Three different 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.

Brave's server is the broadest of the three — eight tools covering news, images, video and local business results, not just web search. brave_llm_context is the one worth knowing about: it returns context shaped for an LLM rather than a raw result list. Brave also lets you switch tools off per deployment with BRAVE_MCP_ENABLED_TOOLS and BRAVE_MCP_DISABLED_TOOLS, which matters when a model keeps reaching for image search during a text task.

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; at $5/1,000 the paid rate is still unbeatable).
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 only feed text to an LLM that writes the answer. The cheapest 2026 stack pairs Tavily's free tier (plus Exa's signup credit) for search with a free LLM tier from Groq, Gemini, or Together AI, orchestrated by CrewAI or LangGraph and traced with Langfuse. Hobby scale: $0/month. Small production (a few hundred daily users): typically $30–80, almost all of it search overage.

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 and tavily-extract; Exa's exposes web_search_exa, web_search_advanced_exa, web_fetch_exa and agent_run; 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

• CrewAI: Free Open-Source Multi-Agent AI Framework for Python — the most natural framework to pair with these search APIs
• 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: ~525 tok/s + What You Can Build — the LLM half of the free agent stack