Brave Search API vs SERP API: The Engine Behind Claude's Search

Millions of people now search the web through Claude. Almost all of them assume that when Claude looks something up, it’s Googling. It isn’t.

Claude’s web search runs on the Brave Search API — an independent index, not Google’s. That single fact reframes a question a lot of developers are quietly asking. If the AI assistant I’m building on searches with Brave, how different is that from the real Google results? Is an “independent index” a genuinely different web, or basically Google with a different logo?

This is really a Brave Search API vs SERP API question. Brave gives you an independent index of the open web. A Google SERP API gives you the live Google results page, scraped and structured. They look interchangeable until you measure them side by side.

So we measured it. We ran the same 500 queries through the Brave Search API and through cloro’s live Google SERP on the same day. The queries were stratified across informational, commercial, transactional, navigational, and local intent. Then we scored how much the two actually agree. The answer is more interesting than either extreme.

The search engine behind Claude

In March 2025, TechCrunch reported that Anthropic appears to power Claude’s web search with Brave. The evidence is circumstantial but strong and consistent: Anthropic lists Brave Search on its subprocessor list — the third parties authorized to process Claude data — and Claude’s web-search tool carries a BraveSearchParams parameter internally. Anthropic hasn’t published a formal “we use Brave” statement, but everything points the same way.

Mechanically, it works like this: Claude formats a search query, sends it to the Brave Search API, gets back Brave’s independent results, reads them, and writes an answer with citations. Anthropic’s web search tool is billed at $10 per 1,000 searches plus token costs. Calling Brave directly runs $5 per 1,000 — so the Claude tool is, roughly, the Brave index plus a model wrapper at double the price. That’s a fine trade if you want Claude to do the reading for you. It also means the results your Claude app grounds on are Brave’s, and the natural next question is how far Brave sits from Google.

What the Brave Search API is (and how to get a key)

The Brave Search API is a commercial API on top of Brave’s own web index. It is the same product Anthropic wires into Claude. Understanding what it returns — and what it costs — is the first half of any Brave Search API vs SERP API decision.

Brave’s independent index

The headline fact is the reason Anthropic can use Brave as a neutral backend. Brave’s independent index contains over 30 billion pages with over 100 million page updates every day. It is not reselling Google or Bing. It crawls and ranks the web itself. That independence is the whole point: a search backend that owes nothing to Google’s business or Bing’s, yet still surfaces the mainstream web.

Brave Search API pricing and free tier

Pricing is simple, and it’s the subtopic people search for most after the key itself. Per Brave’s published pricing, the Search plan includes $5 in free credits every month, then bills $5 per 1,000 requests, with a rate ceiling of 50 queries per second. For a prototype, the monthly free credits cover roughly a thousand requests at no cost. For production, budget five dollars for every thousand searches your agent makes. There are no per-seat fees and no minimum commit, which is why it slots so cleanly under an LLM.

Getting a Brave Search API key

Getting a brave search api key is quick. It’s the step people actually get stuck on:

1. Go to api-dashboard.search.brave.com and register an account.
2. Create a subscription on the Search plan (the free tier is enough to test).
3. Copy your API key from the dashboard.
4. Send it in the X-Subscription-Token header — not as a bearer token. That mistake trips up a lot of first requests:

curl -s "https://api.search.brave.com/res/v1/web/search?q=best+crm+software&count=10" \
  -H "X-Subscription-Token: $BRAVE_API_KEY" \
  -H "Accept: application/json"

Results come back under web.results[]. Each entry carries a url, a title, a description, and a page_age timestamp. That’s the same data Claude is working from when it searches the web for you. If you can read that JSON, you can see exactly what your Claude app is grounding on.

Brave vs Google: how similar are they, really?

Here’s the part only original data can answer. We compared the top 10 results from the Brave Search API against cloro’s live Google SERP for all 500 queries. We scored the overlap on both URLs and domains, so we could separate “different sources” from “same sources, different order.”

They search the same web

Brave’s #1 result came from a domain Google also ranks in its top 10 89% of the time. Google’s own top domain showed up in Brave’s top 10 on 92% of queries. Across the whole set, Brave and Google shared at least one domain on 99.8% of queries — essentially always. Roughly 65% of Google’s top-10 domains appeared somewhere in Brave’s results.

Agreement is highest at the top. The top-3 domains overlap more than the deeper list does. For the results that carry the most weight, Brave and Google draw from the same well of authoritative sources. That is the single most important finding here: the sources barely differ.

The strict URL number looks lower — here’s why

Now the stricter test. If you demand the exact same URL in the same top-10 window, overlap drops to 46.6%. That sounds like disagreement. It mostly isn’t.

The gap measures two things that aren’t “different sources.” The first is ranking order — Brave ranks the same pages in a different sequence. The second is URL-versus-domain granularity, like zoho.com/crm versus zoho.com/crm/small-business. Both point at the same site. Brave also leans harder into forums and community content that Google ranks too, but often lower. Strip those artifacts out and the picture is consistent. Brave isn’t returning a different internet. It’s returning Google’s internet, rearranged.

The overlap tracks query intent

The exact-URL agreement isn’t uniform. It tracks what the searcher is trying to do. On commercial and transactional queries — “best CRM software,” “buy a standing desk” — Brave and Google shared about 5 of 10 URLs. That fell to roughly 4.1 on broad informational queries and 3.8 on local ones.

The pattern is intuitive. The more a query looks like a buying decision, the more tightly the two converge on the same product and review pages. The more local or exploratory it is, the more Brave’s independent ranking wanders. If your workload skews commercial — as most agent and RAG use cases do — expect the higher end of that range.

Where Brave genuinely diverges, and where it’s better

Brave isn’t just a paler Google. It attaches its own metadata that Google’s organic block doesn’t expose. 63% of Brave’s results carried a machine-readable date, with a median age of ~113 days. If your app wants to filter by recency at the API layer, Brave hands you something Google’s SERP doesn’t.

Brave also leans into forums and community content — Reddit threads, independent reviews. That reads as a feature if you want a second opinion on the web. It reads as a quirk if you expected Google’s exact order. Either way, it’s a difference in flavor, not in which web gets searched.

That’s the answer to the question Claude raises. If your agent grounds on Brave — directly or through Claude’s web search — it is seeing substantially the sources Google would show. It is not seeing some parallel web.

The one real gap: Google’s result-page layer

There is a genuine difference, and it’s not in the sources — it’s in everything Google wraps around them.

Because Brave queries its own index rather than scraping Google, it structurally can’t return the Google-specific features that increasingly are the page. On the same 500 queries, Google rendered a People Also Ask block on 77% of them, an AI Overview on 64%, and shopping units on 14%. Brave returns none of these — it gives you organic links plus its own enrichments (discussions, videos, an FAQ block), but not Google’s answer layer.

This is the line that matters. Brave (and Claude) can tell you which pages Google would surface. Neither can tell you what Google actually shows — the AI Overview that now answers the query before any link, the questions people also ask, the products in the shopping carousel. If that layer is what you care about, an independent index is the wrong tool, however close its links are.

What this means for your stack

The Brave Search API vs SERP API choice splits cleanly by use case. The two products aren’t better or worse than each other. They return different things, and you should buy the one whose output you need.

Grounding an LLM or agent

Reach for Brave here. Call it directly at $5/1,000 or inherit it through Claude’s web search at $10/1,000. Either way, your model gets essentially Google’s sources from an independent, privacy-respecting index. For retrieval and citation, that isn’t a compromise. It’s a reasonable default. It’s also what a large share of production AI search already runs on.

Reproducing or measuring the Google page

Reach for a real Google SERP API here. The moment you need what a human sees on Google — the AI Overview, People Also Ask, shopping, and the exact ranking order — an independent index can’t help you, because it isn’t scraping Google. cloro returns the live results page with those features as structured JSON. cloro’s pricing starts at $100/mo for 250,000 credits. A Google Search request is 3 credits, which works out to roughly $0.93–$1.20 per 1,000 queries — actually cheaper per query than Brave, with the full feature layer attached.

Backend	What you get	Price
Brave Search API	Independent index — largely Google’s sources, no feature layer	$5 / 1,000
Anthropic (Claude) web search	The Brave index, read and summarized by Claude	$10 / 1,000 + tokens
cloro (Google SERP)	The real Google page + AI Overview, PAA, shopping	~$0.93–$1.20 / 1,000

At volume, the gap widens — and note that the cheapest way to get the Brave index is Brave itself, not Claude:

Monthly queries	Brave	Anthropic (Claude) web search	cloro (Google SERP)
10,000	~$50	~$100 + tokens	within the $100 base plan
100,000	~$500	~$1,000 + tokens	~$93–$120 in credits
1,000,000	~$5,000	~$10,000 + tokens	~$930–$1,200 in credits

The takeaway isn’t that one price wins — it’s that they buy different things. Brave and Claude buy the same independent index (Claude at a premium for the model wrapper); cloro buys the actual Google page. Pay for the one whose output you need.

Migrating from Brave to a Google SERP API

If you started on Brave (or on Claude’s search) and hit the “I actually need the Google page” wall, the swap is small — both are a single HTTPS call:

Brave  →  GET  https://api.search.brave.com/res/v1/web/search?q=<query>
          Header: X-Subscription-Token: <key>
          Results: web.results[] → { url, title, description, page_age }

cloro  →  POST https://api.cloro.dev/v1/monitor/google
          Header: Authorization: Bearer <key>
          Body:   { "query": "<query>", "country": "US",
                    "include": { "aioverview": { "markdown": true } } }
          Results: result.organicResults[] → { link, title, snippet, position }
          Plus:    result.aioverview, result.peopleAlsoAsk, result.shoppingCards

Map web.results[].url to result.organicResults[].link and the organic list ports directly — you’re mostly getting back the same domains. Everything under result.aioverview, result.peopleAlsoAsk, and result.shoppingCards is the surface area Brave never had.

What changes and what stays the same

The organic list is the easy part. Because Brave and Google share the same sources on 99.8% of queries, your existing prompts and parsing logic keep working. The domains your agent already trusts still show up. What you gain is the layer on top: an AI Overview answer that resolves the query before any link, the questions real users also ask, and the shopping units for commercial intent. You don’t have to rewrite your grounding pipeline to add those. You add fields, you don’t replace them. Many teams run both — Brave for cheap, high-volume grounding, and a Google SERP API on the smaller slice of queries where the page itself is the product.

When to use which

• Brave Search API (or Claude’s web search): you want an independent, privacy-first index that draws on the same web as Google, at a low price, and you don’t need Google’s result-page features. Ideal for RAG, agents, and any grounding workload — which is exactly why Anthropic built Claude’s search on it.
• A real Google SERP API (cloro): you need the page users actually see — rank tracking, SEO, or SERP scraping, or AI-Overview and PAA visibility monitoring. The sources are similar; the page, and everything Google layers onto it, is not.

The headline everyone misses is that “AI search” often is Brave search — and Brave is far closer to Google than its independent-index label suggests. On 500 queries the two agreed on the top source nearly nine times in ten. Where they part ways isn’t the web they see; it’s the page Google builds on top of it. Know which one your product actually needs.

This is one leg of a four-part study — we ran the identical 500-query test on every major search API. See how Tavily, Exa, and Perplexity compare to the real Google SERP.

Need the real Google SERP — features intact? See how cloro’s web search API returns it, or compare the field in our rundown of the best SERP APIs.