Best web search API for AI agents: 11 tested

The best web search API for AI agents is the one whose answer your agent can use without a second call. Some return links and short descriptions. Some return excerpts written for a model. One returned the text of every page. On 2026-10-28 we sent the same query to 11 web search APIs in the looot catalog and looked at what came back, how long it took and what each one needed as input.

This post ranks those providers by live price per search, shows the test, and helps you choose. It ends with a prompt and a FAQ. The ranking with logos lives on the best web search API page.

Last checked 2026-10-28, against looot's live catalog and 11 paid search runs.

Best web search API: the short answer

Each bullet names one need. Prices are in the live table, because they change.

• Brave Search, best for an independent index: titles, links and descriptions from Brave's own crawl.
• Exa, best for search by meaning: it matches what the query is about, then finds similar pages.
• Tavily, best for snippets an agent can quote: results with content, plus extract and crawl endpoints.
• Linkup, best for answers with sources: search results, a sourced answer or JSON in your schema.
• Parallel, best for a goal you describe: excerpts chosen for an objective in plain words.
• Jina, best for page text in one call: it reads every result into text.
• Limadata, best for plain Google results: a query and a page number, nothing else.

How we ranked these web search APIs

We rank by the live price per call of each provider's `web.search` endpoint, read from the looot catalog when the page loads. Only endpoints billed per call are in the list. Four search endpoints in the catalog bill per result, so their price per search depends on how many results you ask for, and they are left out. Some providers price by mode or depth, and a deeper setting costs more than the listed price. Vendors outside the catalog are not ranked.

We also ran each provider once on 2026-10-28 with the query "email verification api for ai agents". One query shows the shape of each answer and the input each one needs. It does not measure result quality, so it does not move the rank.

One query through 11 web search APIs

Seconds are from the start to the end of the run. Results is the count in the answer, where we could count it.

Two things stand out. Input names differ: four of the eleven rejected our first call because the query field had another name or a required setting was missing, and the rejected calls cost nothing. And Jina was the slowest by far, because it read every page. That is the trade: one slow call with text, or a fast call plus a scrape for each link you open.

1. Brave Search, best for an independent index

Brave's `brave-search-res-web-search` searches Brave's own index and returns titles, links and descriptions, grouped in blocks. News, images and videos are separate endpoints.

• Best for: an agent that picks links and reads them with its own scraper; a second opinion next to Google results.
• Strengths: fast; its own index, so results differ from Google's.
• Limits: no page text in the answer; the answer is large, so trim it before it reaches the model.
• Does not fit: an agent with no scraper that needs text to quote.

2. Exa, best for search by meaning

Exa's `exa-search` runs a neural search that matches the meaning of the query and can add page text. The same provider has answer, similar pages and article text endpoints.

• Best for: finding companies or papers like a known one; research questions written as sentences.
• Strengths: finds pages a keyword search misses; similar pages from one example.
• Limits: a short keyword query can rank differently than on Google.
• Does not fit: rank checks, which need Google's order.

3. Tavily, best for snippets an agent can quote

Tavily's `tavily-search` returns results built for an agent, each with a content snippet, and can add a short answer. Extract, crawl and site map endpoints cover the next step.

• Best for: a research agent that cites sources; a search step inside a longer workflow.
• Strengths: text a model can read at once; follow-up endpoints from the same provider.
• Limits: snippets are short, so long pages still need an extract call.
• Does not fit: a pipeline that only needs links.

4. Linkup, best for answers with sources

Linkup's `linkup-search` takes a question and returns search results, a sourced answer or JSON in a schema you send. You choose fast, standard or deep.

• Best for: questions with one answer; filling a table from the web in your own format.
• Strengths: three output types from one endpoint; date and domain filters.
• Limits: three fields are required, and deep costs more per call than the listed price.
• Does not fit: a caller that sends only a query string.

5. Parallel, best for a goal you describe

Parallel's `parallel-search` takes one to three short queries plus an objective in plain words, and returns links with excerpts chosen for that objective.

• Best for: agents that already know why they search; long answers kept short with a character cap.
• Strengths: excerpts tied to your goal; extract and research endpoints next to it.
• Limits: a single query string is not its input, so tools built for other providers need a small change.
• Does not fit: a drop-in replacement for a one-field search.

6. Jina, best for page text in one call

Jina's `jina-search` searches and reads each result into text. A page to markdown endpoint and a reranker come from the same provider.

• Best for: an agent with no scraper; summaries of the top results.
• Strengths: one call gives the text.
• Limits: the slowest answer on our test, and the answer is large.
• Does not fit: anything that needs an answer in a second or two.

7. Limadata, best for plain Google results

Limadata's `limadata-api-search-web` returns Google results for a query, page by page.

• Best for: "what does Google show for this"; quick checks with no settings.
• Strengths: the simplest input of the list.
• Limits: no country, language or date filter.
• Does not fit: local or dated searches. For positions and features, use the SERP API ranking instead.

Octen, You.com, Keenable and Olostep are in the live table and on the ranked page. Octen and Keenable both filter by date, and You.com splits web and news results.

How to choose a web search API for an agent

Start from what the agent does with the results.

Does the agent read the pages?

If yes, pick a provider that returns text, such as Tavily, Exa with page text or Jina. If it only picks links, Brave Search, Limadata or Olostep are enough.

Does the search have a goal?

If the agent knows why it searches, Parallel and Linkup use that goal. If it only has keywords, any provider here works.

Do you need a second step from the same provider?

Tavily, Exa, Linkup and Olostep have extract, answer or scrape endpoints, so one provider covers search and read. The web search API guide shows that flow.

Will you run the same searches again?

Rerunning on a timer needs scheduled runs, not available yet. Run them by hand and compare the links.

Try it

What this test does not show

One query is a sample. It shows the shape of each answer, the input each provider needs and how long one call took from our workspace. It does not rate relevance, and a provider that was fast once can be slow on another query. For vendor list prices outside looot, read web search API pricing.