The short answer
Barely. On the same query, two search APIs return 2.1 to 2.5 of the same ten pages. Pool the four top-ten lists and you hold 30 distinct pages out of a possible 40, and 79% of them came from one engine only. But when engines do agree, it means something: a page that all four returned was the page holding the answer 25% of the time, against 2.6% for a page only one engine returned.
These numbers come from 4,365 queries sent to Exa, Brave, Parallel and Perplexity on 27 October 2026. Every call is public, and so are the four scripts that turn the calls into this page.
What was measured
The queries are the 485 questions of the supersearch-tests panel, each written three ways and each run three times, which is 4,365 query instances per engine. Every engine was called through the Jevlin router pinned to that single provider, so all four saw the same query string at the same moment and their results passed through the same URL normalisation. We compare the first ten results of each.
The panel was built to measure something else: how often the page with the answer is in the top ten. That result is in the original write-up and is not repeated here. This page asks a question the first one did not: how much do the engines overlap, and is overlap worth anything?
Two pages count as the same page when their URLs match after lowercasing the host, dropping www. and mobile prefixes, removing tracking parameters and fragments, and trimming a trailing slash or index.html. The rule is the dataset's own and is applied to every engine alike.
A baseline: how much does an engine agree with itself?
A low overlap between two engines means little unless you know what a high one looks like. So we measured each engine against itself, twice. First the identical query run again minutes later. Then the same question reworded.
Run the identical query twice and an engine returns nearly the same ten pages: 9.3 of ten on average. That is the ceiling, and it shows the lists are stable, not noise. Reword the query and the same engine keeps only 3.4 of its ten. Switch to a different engine with the query unchanged and you keep 2.3.
Rewording a query changes an engine's results almost as much as switching engines does. An agent that searches once, with one wording, on one index, is seeing a small and fairly arbitrary slice.
Engine against engine
Pages shared out of ten, for every pair. The grey diagonal is each engine against its own second run.
| Exa | Brave | Parallel | Perplexity | itself, query reworded | results no other engine returned | |
|---|---|---|---|---|---|---|
| Exa | 9.5 | 2.3 | 2.5 | 2.1 | 3.5 | 60% |
| Brave | 2.3 | 9.8 | 2.5 | 2.2 | 3.5 | 60% |
| Parallel | 2.5 | 2.5 | 8.7 | 2.1 | 3.6 | 58% |
| Perplexity | 2.1 | 2.2 | 2.1 | 9.3 | 2.9 | 64% |
No pair stands out. The closest are Exa with Parallel and Brave with Parallel, at 2.5 of ten. The furthest apart are Exa and Perplexity at 2.1. In 7% to 13% of queries, depending on the pair, two engines had no page in common at all. Around six in ten of any engine's results were returned by none of the other three.
They agree more about sites than about pages. Counting registrable domains instead of URLs, a pair's overlap roughly doubles, to between 28% and 36% by Jaccard index. The engines often find the same site and then pick different pages from it.
What the pooled results look like
Put the four lists together for one query. Of the 30 distinct pages, this is how many engines returned each:
Only 3% of pooled pages were returned by all four. A merged list that favours agreement is choosing from the 21% of pages that at least two engines returned.
Is agreement evidence?
For each of the 485 questions the panel knows which page holds the answer. So for every page in the pooled results we can ask: how many engines returned it, and was it the answer page? This uses the first wording of each question across three runs, which is 43,734 pages.
The chance that a returned page is the answer page rises with each engine that agrees: 2.6%, 6.2%, 12.8%, 25.3%. A page all four return is about 10 times as likely to be the right one as a page only one returns. The bars carry 95% intervals and none of them overlap.
The other side of that chart matters as much. Of the 1,844 times an answer page appeared, 903 were on a page only one engine returned. Agreement is a good reason to read a page first. It is not a reason to discard the pages nobody agreed on, because that is where half the answers are.
How many engines find the answer
Per question: how many of the four engines had the answer page in their top ten?
All four had it for 25% of questions, and none had it for 26%. In between sits the part that matters for anyone choosing a search API: for 17.5% of questions exactly one engine had the answer page. Which engine that was varied: Exa for 6.3% of questions, Brave for 4.7%, Parallel for 4.2% and Perplexity for 2.3%.
These are not coin flips that would land differently on another run. Counting only questions where one engine found the answer page in all three runs and the other three missed it in all three, there are 73 such questions out of 485: 26 for Exa, 22 for Brave, 16 for Parallel and 9 for Perplexity. One from each:
- where should i put my e2e checks when working with nuxt
answer page: github.com/nuxt/nuxt/blob/HEAD/docs/2.directory-structure/1.test.md#chunk0
Only Exa returned it, at rank 5, in all three runs. The other three engines missed it in all three. - does dagster have a managed way to run workflows without handling infrastructure myself
answer page: github.com/dagster-io/dagster/blob/HEAD/docs/docs/deployment/index.md#chunk0
Only Brave returned it, at rank 7, in all three runs. The other three engines missed it in all three. - how do i write a not-equal-to condition in grafana when building a search
answer page: github.com/grafana/grafana/blob/HEAD/docs/sources/datasources/elasticsearch/template-v
Only Parallel returned it, at rank 3, in all three runs. The other three engines missed it in all three. - does zenml include any user interface improvements for the annotation widget it uses
answer page: github.com/zenml-io/zenml/blob/HEAD/docs/book/component-guide/annotators/pigeon.md#chu
Only Perplexity returned it, at rank 10, in all three runs. The other three engines missed it in all three.
Read as coverage, the table below says the same thing from the other direction. When Brave, Parallel or Perplexity found an answer page, Exa had it too about 84% of the time. When Exa found one, each of the others had it 65% to 72% of the time.
| of the answer pages this engine found | Exa also had it | Brave also had it | Parallel also had it | Perplexity also had it |
|---|---|---|---|---|
| Exa | – | 72% | 66% | 65% |
| Brave | 84% | – | 64% | 70% |
| Parallel | 84% | 70% | – | 71% |
| Perplexity | 84% | 77% | 72% | – |
The leader changes with the kind of question
The panel is three public question sets. Share of questions with the answer page in the top ten, with 95% intervals:
| kind of question | Exa | Brave | Parallel | Perplexity | leader’s margin, 95% interval |
|---|---|---|---|---|---|
| Library documentation DevDex, 201 questions | 64% 57 to 70 | 53% 46 to 60 | 62% 55 to 68 | 54% 48 to 61 | Exa over Parallel: +1.7 -3.5 to +6.8 |
| Hard factual questions Seal-Hard, 254 questions | 54% 47 to 60 | 50% 44 to 56 | 35% 29 to 41 | 38% 32 to 44 | Exa over Brave: +3.7 -2.5 to +10.0 |
| Vendor API tickets OB-Code, 30 questions | 50% 33 to 67 | 19% 9 to 36 | 19% 9 to 36 | 37% 22 to 54 | Exa over Perplexity: +13.3 -3.3 to +30.0 |
Exa leads all three, but never by a margin the data can confirm: every interval in the last column includes zero. The order behind it reshuffles. Parallel is within two points of Exa on library documentation and 19 points behind on factual questions. Brave is the reverse: second on factual questions, last on documentation. On the 30 vendor tickets Brave and Parallel each found the answer page fewer than one time in five, though thirty tickets is too few to rank anyone on.
So “which search API is best” has no stable answer in this data beyond “Exa, narrowly, and it depends”.
Where each engine sends you
Across all 4,365 queries, each engine returned about 43,000 results. The sites they came from:
| engine | distinct sites | share from its ten most-returned sites | most-returned sites |
|---|---|---|---|
| Exa | 2,790 | 29% | github.com 12.3%, wikipedia.org 6.6%, huggingface.co 2.1%, servicenow.com 1.5% |
| Brave | 2,706 | 25% | wikipedia.org 6.9%, github.com 6.8%, reddit.com 2.0%, huggingface.co 1.7% |
| Parallel | 2,704 | 25% | github.com 7.6%, wikipedia.org 5.6%, huggingface.co 2.5%, servicenow.com 1.7% |
| Perplexity | 2,451 | 25% | wikipedia.org 7.8%, github.com 4.7%, huggingface.co 3.3%, servicenow.com 2.0% |
GitHub makes up 12% of Exa's results and 5% of Perplexity's. Brave is the only engine with Reddit among its five most-returned sites. Perplexity draws on the fewest distinct sites. The panel is developer documentation and factual questions, so these shares describe the engines on that material and nothing wider.
What this does not show
- Four engines, one day. Serper and TinyFish, which Jevlin also runs, were not part of this panel. All calls were made on 27 October 2026, and indexes change.
- Ten results each. Deeper lists would overlap more. Ten is what an agent usually reads.
- One kind of material. 485 questions about developer documentation, vendor APIs and hard facts, four in five of them answered on a GitHub-hosted docs page or on Wikipedia. Shopping, news and local queries may behave differently. For news, see the election-night measurement.
- The answer page is one page. Another page may also hold the answer. A result that is not the gold page is not necessarily wrong, so the percentages in “Is agreement evidence?” are floors.
- We sell the fan-out. Jevlin asks several engines in one call, so low overlap is convenient for us. That is why the calls, the scoring rule and the scripts are public: check the arithmetic.
Data and method
The calls are in the supersearch-tests dataset on Hugging Face, CC-BY-4.0. The analysis uses the dataset's own score.py for URL normalisation and answer-page matching, and reproduces its published hit rates exactly (Exa 57.5%, Brave 49.1%, Parallel 45.1%, Perplexity 44.5%) before computing anything new.
The scripts and the numbers behind every chart on this page: load.py, agree.py, extra.py, kinds.py and data.json.
To cite: Gaurav Shukla, “Do search APIs agree?”, Jevlin, 10 November 2026, jevlin.ai/research/search-engine-agreement. Data collected 27 October 2026.