Web Search APIs, Then vs Now

Short answer: two years ago a web search API handed your model ten links and two-line snippets, and the reading was your problem. Today the best ones read the pages for you, and on OpenAI's SimpleQA benchmark four APIs now clear 95%: Exa, Parallel, browserfoundry and You.com, within 0.3 points of each other. browserfoundry deep search scores 95.30% with no model in the loop (the answer has to be in the data the API returns) at $3 per 1,000 requests, the lowest price of the four. Every number below links to its source, and our script and all 1,141 records are public on GitHub.

What changed: web search APIs then vs now

The jump from 72% to 95% isn't a better ranking algorithm. It's reading. On our own run, search snippets alone held the answer for 72.4% of questions. Reading every candidate page end to end took that to 87.7%, before any judging. That reading step is the difference between the two eras.

Who scores what on SimpleQA?

SimpleQA is OpenAI's benchmark of 4,326 short factual questions, each written to trip up language models and each with one verified answer. It has become the standard accuracy test for search APIs. Here is each provider's best published score next to what that configuration costs:

SimpleQA score and price per 1,000 requests, every provider

Data

Provider	SimpleQA	Price per 1,000	What that price buys	Harness	Score source
Exa (full page)	95.47	$17.00	$7 search + 10 pages of contents at $1 per 1,000 pages	Answer + judge, full-page contents (You.com, Sep 2026)	you.com/resources/highlights-parameter-web-search-api
Parallel (advanced)	95.33	$5.00	Search API, 10 results, advanced mode	Answer + judge, advanced mode (You.com, Sep 2026)	you.com/resources/highlights-parameter-web-search-api
browserfoundry deep search	95.30	$3.00	Full pipeline: live resolution, full-page reads, re-rank	Retrieval only, no reader model or judge. n=1,000, seed 42	github.com/Keirolabs-API/deep-endpoint-benchmark-results
You.com (Highlights)	95.17	$5.00	Web Search API, Highlights included	Answer + judge, Highlights extraction (self-published, Sep 2026)	you.com/resources/highlights-parameter-web-search-api
Brave AI Grounding	94.1 F1	$4.00	Answers API, plus $5 per million tokens in and out	F1 score, multi-search grounding (self-published)	brave.com/blog/ai-grounding
Linkup Fast	94 F1	$5.00	Search, fast depth	F1 score, sub-second search APIs (self-published)	linkup.so/benchmarks
Tavily	93.3	$8.00	Basic search, pay as you go	GPT-4.1 answers, official classifier (self-published)	tavily.com blog
Perplexity Search	85.92	$5.00	Search API	GPT-4.1 answers, official classifier (Tavily's harness)	github.com/tavily-ai/tavily-search-evals
Google (via Serper)	82.15	$1.00	Serper, 50,000-search pack; Google has no official web search API	SERP results, GPT-4.1 answers (Tavily's harness)	github.com/tavily-ai/tavily-search-evals

Three things to read this chart correctly:

1. The top four are tied. 95.47, 95.33, 95.30 and 95.17 sit within 0.3 points of each other, which is inside the run-to-run variance of this benchmark. Anyone telling you one of them is "the most accurate" off this data is overselling.
2. The tests differ. Every competitor score is an answering pipeline: an LLM reads the provider's results, writes an answer, and a judge model grades it. Ours is retrieval only: we check whether the gold answer appears in what the API returned, with no reader model to rephrase, infer or already know the answer. Brave and Linkup publish F1 rather than accuracy.
3. These are each vendor's best runs. Most are self-published or run by a competitor, and each source is in the data table under the chart. We've used the highest number we could find for each provider, not the lowest.

What does 95% cost?

Accuracy is a tie at the top, so the deciding question is price. Here are the four APIs above 95%, with the list price per 1,000 requests for the exact configuration behind each score:

At $3, browserfoundry costs 40% less than Parallel or You.com and about 80% less than Exa's full-page setup for the same tier of accuracy, before counting the language-model tokens their pipelines need to turn results into answers. Prices are from each vendor's pricing page on October 7, 2026; check them for your own volume.

How did we measure 95.30%?

The runner is one zero-dependency Node file, testbench.js in the public benchmark repo. It does four things.

1. Draws a deterministic sample. It downloads OpenAI's public SimpleQA CSV and takes a seeded Fisher–Yates sample of 1,000 questions. The same seed always gives the same questions:

// mulberry32 PRNG + Fisher–Yates: deterministic per seed
function sampleRows(rows, n, seed) {
  const rand = mulberry32(seed);
  const idx = rows.map((_, i) => i);
  for (let i = idx.length - 1; i > 0; i--) {
    const j = Math.floor(rand() * (i + 1));
    [idx[i], idx[j]] = [idx[j], idx[i]];
  }
  return idx.slice(0, n).map((i) => rows[i]);
}

2. Calls deep search once per question, asking for 10 results, and keeps the full response.

3. Checks for the gold answer mechanically. Both sides are normalized (lowercased, articles and punctuation stripped), then it's a substring test over every snippet and every page:

function normalize2(s) {
  return String(s || "")
    .toLowerCase()
    .replace(/\b(a|an|the)\b/g, " ")
    .replace(/[^a-z0-9 ]/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}
const goldIn = (text, gold) =>
  !!text && normalize2(gold) !== "" && normalize2(text).includes(normalize2(gold));

4. Writes every record to results.json: question, gold answer, verdict and the complete returned payload, 1,141 records in all. Any call we judged, you can open and check.

To rerun it:

git clone https://github.com/Keirolabs-API/deep-endpoint-benchmark-results
cd deep-endpoint-benchmark-results
export SEARCH_API_KEY=your_api_key         # from your browserfoundry dashboard
SAMPLE_SIZE=1000 SAMPLE_SEED=42 node testbench.js

What counts as a hit?

The raw substring check scored 87.9%. A plain substring test is too strict for facts, though: "July 4, 1976" and "4 July 1976" are the same answer, and so are "TX" and "Texas". Every raw miss was audited by hand under fixed rules, and the audit was deliberately stingy:

74 raw misses passed the audit and 43 stayed misses: 87.9% becomes 95.3%. Every rescued record is in results.json for anyone who wants to check our calls.

Where do the points come from?

Where the 95.3 points come from

Data

Stage	Accuracy	Added
Search snippets only	72.4%	—
+ pages read in full	87.7%	+15.3
+ variant-form judging	95.3%	+7.6

Snippets alone hold the answer 72.4% of the time, which is roughly the "then" column above. Reading every candidate page in full adds 15.3 points, and 175 questions were answered only by full page text. That's what deep search does:

1. Compile. Turn the question into the specific fact it's asking for: an entity, an attribute, and the shape of the answer (a date, a number, a name).
2. Resolve. Find about 10 pages on the live web that could carry that fact.
3. Prove. Read every candidate in full and score each by how directly it states the answer: 7.9 pages per question on average.
4. Assemble. Return the pages ranked by evidence, with snippets and full text.

All that reading gives deep search a median response time of 14.7 seconds. It's built for research agents, verification steps and citation-grounded answers. For interactive use, /search/fast returns in about a second.

Is the score consistent?

Consistency across 20 seeded chunks of 50

Data

Chunk offset	Raw	Judged	Judged %
100	39/50	46/50	92%
150	46/50	49/50	98%
200	43/50	47/50	94%
250	44/50	48/50	96%
300	43/50	48/50	96%
350	44/50	48/50	96%
400	44/50	49/50	98%
450	42/50	49/50	98%
500	44/50	46/50	92%
550	42/50	43/50	86%
600	44/50	47/50	94%
650	42/50	48/50	96%
700	44/50	47/50	94%
750	44/50	47/50	94%
800	49/50	50/50	100%
850	43/50	49/50	98%
900	41/50	45/50	90%
950	45/50	49/50	98%
1000	48/50	48/50	96%
1100	48/50	50/50	100%

The 1,000 questions ran as 20 seeded chunks of 50. Judged accuracy ranged from 86% to 100%, median 96%, with two perfect chunks, so the score isn't carried by an easy slice. One additional chunk ran during a credit outage on our side and is excluded; its records stay in results.json.

What do the 43 misses look like?

What are the limits of this result?

• It's our harness, run by us. The code and every payload are public, but it isn't an independent evaluation. Anyone can rerun it with a free key, and we'd welcome a third party doing so.
• It isn't the same test as the others. Retrieval-only and answer-then-judge measure different things. A reader model can lose points the retrieval had, or gain points from what it already knows.
• The variant-form audit was done by hand, under published rules; a stricter reader could reclassify some of the 74 rescues.
• SimpleQA is short factual lookups. It says nothing about multi-hop research or freshness.

Sources

• Our code, sample and all 1,141 records: the benchmark repo on GitHub
• Exa, Parallel and You.com scores: You.com, "Web Search with Highlights: 95.17% on SimpleQA" (Sep 1, 2026)
• Brave: Brave AI Grounding · Linkup: Linkup benchmarks · Tavily: Tavily blog · Perplexity and Google: tavily-search-evals
• Prices: Exa, Parallel, You.com, Brave, Linkup, Tavily, Perplexity
• SimpleQA: OpenAI
• Deep search docs: browserfoundry docs