Exa Search vs Google: What Neural Search Retrieves vs What Google Shows

Most search APIs are quietly trying to be Google — cheaper, or with cleaner JSON, or without the scraping. Exa isn’t. It’s built on a fundamentally different idea of what “search” means, and when you measure it against Google, the numbers make that unmistakable.

Exa search is neural search: it retrieves web pages by meaning rather than by keyword match. That single design choice raises an obvious question for anyone building on it — if Exa isn’t ranking pages the way Google does, how far does it actually drift from the results a person would see? Is “search built for AI” a better web, a narrower one, or just a different one?

So we measured it. We ran the same 500 queries — stratified across informational, commercial, transactional, navigational, and local intent — through the Exa Search API and through cloro’s live Google SERP, the same day, and scored how much they agree. Of the search APIs we’ve put through this test, Exa is the outlier. That’s the story.

How Exa search works: retrieval by meaning, not keywords

Traditional search matches words. You type “best crm for startups,” and the engine finds pages containing those tokens, then ranks them by links, authority, and hundreds of other signals. Exa does something different. In its own description, Exa converts every document it indexes “into a vector (aka an embedding)” that captures the document’s meaning, converts your query into an embedding too, and returns “the closest matches” in that semantic space.

The framing Exa uses is that Exa search “predicts specific links on the web given their relevance to a query” — where a language model predicts the next word, Exa’s transformer-based model predicts the next link. It “uses transformers for semantic understanding, handling complex queries based on meaning” rather than keyword overlap. Practically, that means Exa can match the idea of a query even when the target page shares few of its literal words — and it will happily surface a niche essay, a research paper, or a small blog that Google’s keyword-and-authority ranking would bury on page 4.

That is the whole pitch of “search built for AI.” An agent doing research often wants the non-obvious, semantically adjacent source, not the ten SEO-optimized pages that happen to rank. Exa is engineered for exactly that. The question is what you give up when you take it.

What the Exa search API is, and how to call it

Exa search is a commercial API on top of its own neural index. You get an Exa search API key at dashboard.exa.ai, then post a query:

curl -s "https://api.exa.ai/search" \
  -H "x-api-key: $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "best crm software for startups", "type": "neural", "numResults": 10}'

Results come back under results[], each with a url, title, publishedDate, and author. Add "type": "auto" to let Exa choose between neural and keyword retrieval per query, or "type": "keyword" to force a literal match. Pull page text in the same call with a contents block.

The pricing is straightforward, and worth knowing before you architect around it. Per Exa’s published pricing, the Search API costs $7 per 1,000 requests for up to 10 results, plus $1 per 1,000 requests for each result above 10, with 20,000 requests per month free. Pulling page contents is an extra $1 per 1,000 pages per content type. That free tier is generous for prototyping; the per-query cost above it is higher than most Google SERP APIs, which matters once you’re at volume.

One thing our run made concrete: Exa returned no generative answer on any of the 500 queries — it’s pure retrieval, a ranked list of links, not an answer engine. If you want a synthesized answer you bring your own model. What Exa gives you is the retrieval layer, and that layer is where it diverges from Google.

Exa search vs Google: how different are they, really?

Here’s what only original data can settle. We compared the top 10 results from the Exa Search API against cloro’s live Google SERP for all 500 queries, on both URLs and domains.

They search a different web. Exact top-10 URL overlap between Exa search and Google was 32.3% — the lowest of any search API we’ve run through this test (Brave came in around 47%, Tavily around 60%). On domains, only 43.5% of Google’s top-10 domains appeared anywhere in Exa’s top 10, and the average domain Jaccard was just 0.298. Where a keyword engine like Brave returns essentially Google’s web in a different order, Exa returns a meaningfully different set of pages.

And it’s not returning noise — it’s returning discovery. Across the 500 queries, Exa surfaced 2,396 distinct domains to Google’s 1,691, and 1,481 of Exa’s domains — about 62% — never appeared in Google’s top 10 at all. That’s the neural index doing its job: pulling in semantically related sources that Google’s ranking pushes down or leaves off entirely. For a research agent, that long tail is the value. For anyone trying to mirror Google, it’s the problem.

But it stays anchored at the very top. This is the nuance that keeps Exa honest. Its #1 result was a domain Google also ranks 67.8% of the time, and Google’s own top domain showed up somewhere in Exa’s top 10 on 64.0% of queries. Across the whole set, Exa and Google shared at least one domain on 95.4% of queries. So Exa isn’t off in a parallel internet — for most queries it agrees with Google on the single most authoritative source, then diverges as it goes deeper. The top-3 domain Jaccard (0.242) confirms it: agreement is real but thin, concentrated at the apex and thinning fast below it.

The divergence is widest exactly where discovery matters. Segmented by intent, Exa’s domain recall against Google was highest on transactional queries (51.7% — buying-decision pages converge) and lowest on informational ones (37.3%). In other words, the more a query looks like open-ended research — the queries where a novel source is most useful — the more Exa wanders from Google. That’s the feature and the risk in one line: Exa is most different precisely when you’d most want it to be, and least reproducible precisely where you might have hoped to trust it as a Google stand-in.

One more practical note: 48% of Exa’s results carried a machine-readable date, so if your pipeline wants to filter by recency at the API layer, Exa hands you something Google’s organic block doesn’t expose as cleanly.

The gap that no neural index can close: Google’s feature layer

There’s a second, harder difference — and it isn’t about which links you get. It’s about everything Google wraps around them.

Because Exa queries its own neural index rather than scraping Google, it structurally can’t return the Google-specific features that increasingly are the results 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%. Exa returns none of these. It gives you a ranked list of semantically relevant links — nothing more, by design.

This is the line that matters for choosing a tool. Exa can tell you which pages are about your query. It cannot tell you what Google shows for it — the AI Overview that now answers many queries before any link, the questions people also ask, the products in the shopping carousel, or the exact ranking order a user sees. If that layer is what your product depends on, a neural index is the wrong instrument, however smart its retrieval.

What this means for your stack

The Exa-vs-Google result splits cleanly by use case — more cleanly than for any keyword-based API, because the divergence is bigger.

Research, discovery, and RAG. This is Exa’s home turf. When you want your agent to find the non-obvious source — a technical write-up, a primary document, a small site Google ranks on page 5 — neural retrieval is a genuine advantage, not a compromise. The 62% of Exa domains that Google’s top 10 never surfaces are the whole point. If your workload rewards novelty and semantic breadth over reproducing the mainstream ranking, Exa earns its price.

SEO, rank tracking, brand monitoring, and anything user-facing. Here the same divergence is a bug. If you need to know where you rank on Google, what the AI Overview says about your brand, or what a customer actually sees when they search — Exa can’t tell you, because it isn’t ranking or scraping Google. You need a real Google SERP API. cloro returns the live results page, with the AI Overview, People Also Ask, and shopping units, 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 — cheaper per query than Exa, with the full feature layer attached.

Backend	What you get	Price
Exa Search API	Neural index — a different, discovery-oriented web; no feature layer	$7 / 1,000 (up to 10 results)
cloro (Google SERP)	The real Google page + AI Overview, PAA, shopping, exact ranking	~$0.93–$1.20 / 1,000

At volume, the two buy genuinely different things — and the per-query economics favor the SERP API:

Monthly queries	Exa (neural search)	cloro (Google SERP)
10,000	free (within 20k tier)	within the $100 base plan
100,000	~$560	~$93–$120 in credits
1,000,000	~$6,860	~$930–$1,200 in credits

The takeaway isn’t that one price wins. It’s that Exa and a SERP API are answering different questions — “what’s semantically related to this query?” versus “what does Google actually rank and show?” Pay for the one whose output your product needs.

Using Exa and a SERP API together

If you already build on Exa and hit the “I actually need the Google page” wall, you don’t rip it out — you add the SERP layer alongside it. Both are a single HTTPS call:

Exa    →  POST https://api.exa.ai/search
          Header: x-api-key: <key>
          Body:   { "query": "<query>", "type": "neural", "numResults": 10 }
          Results: results[] → { url, title, publishedDate, author }

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

The pattern that works: retrieve broadly with Exa to surface semantically related sources for your model, then verify against the live SERP with cloro when you need to know what Google actually ranks and shows. Exa’s results[].url gives you discovery; cloro’s result.organicResults[].link plus result.aioverview, result.peopleAlsoAsk, and result.shoppingCards give you the real page. They’re complements, not substitutes.

When to use which

• Exa search API: you want neural retrieval that finds semantically related pages Google buries — research, discovery, RAG, and agents that benefit from novelty. Exa search exists to return a different, meaning-ranked slice of the web, and across our 500 queries it delivered exactly that.
• A real Google SERP API (cloro): you need the page users actually see — rank tracking, SEO, or SERP scraping, brand monitoring, and AI-Overview or People Also Ask visibility. Exa can’t reproduce it, because it isn’t scraping Google.

The headline most “AI search” coverage misses is that Exa isn’t a cheaper Google — it’s a different kind of search entirely. On 500 queries it agreed with Google’s top source about two times in three, then went its own way, surfacing a web that’s 62% invisible to Google’s top 10. That divergence is Exa’s product, not its flaw. Just know which web your application actually needs — the one Exa discovers, or the one Google shows.

This is one leg of a four-part study — we ran the identical 500-query test on every major search API. See how Brave, Tavily, 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.