Web search API for AI agents: a buyer's guide

Q: What is the most important feature in a web search API for AI agents?

Predictable behavior under load: stable result shape, sub-second tiers, clear rate limits, and a plan for failure. Price matters once those are in place, because an agent fleet multiplies every per-call cost by thousands.

Q: How much does web search cost per agent run?

At list prices through Mux, a run with four 10-result searches costs between $0.004 on parallel/fast and $0.048 on exa/deep. A mixed plan of three cheap searches and one full-text search is about $0.01 per run.

Q: Do I need full page text or are snippets enough?

For ranking, citation and deciding what to open next, snippets are enough. For summarizing or extracting facts from a page, you want full text. Only Exa returns it inline through Mux; Tavily sells it through an extract endpoint.

Q: How do I stop one agent from spending the whole budget?

Give each agent its own API key with a USD limit and a daily, weekly or monthly reset. Requests over the limit return 402 keylimitexceeded and are not charged. To make your first call and see real costs and latencies, start at the quickstart.

A web search API for AI agents has to do a different job than one built for a search box: the caller is a program that will issue thousands of queries, read snippets or full pages rather than click, and keep going when a call fails. The things that matter are latency, cost per call, structured results, filters, rate limits and what happens on failure. This guide lists those requirements, compares six providers on qualitative axes, and works through what 1,000 agent runs cost at list price.

Mux appears here as a router over Exa, Parallel and Keenable, not as a search engine. The other providers are described from their public positioning, and the numbers quoted for them were checked on their own sites in October 2026.

What agents need from a search API#

Latency#

An agent loop that searches three times before answering spends three round trips on search alone. Sub-second tiers exist on every major provider now, and the difference between 200 ms and 3 s is the difference between a usable chat tool and a background job. Decide which steps need the fast tier and which can wait for a better one.

Cost per call#

An agent fleet can search a few times a second. At that volume the gap between $1 and $8 per 1,000 calls is the gap between a rounding error and a line item. Also check how extra results are billed, because asking for 50 results can cost more than the base request.

Structured results#

You want a stable JSON shape with title, URL, snippet, published date and optionally content, so results go straight into a prompt or a parser. Providers that return Google SERP features serve a different kind of agent than providers that return clean semantic matches.

Snippets vs full text#

Snippets are enough for ranking and citation. RAG and summarization usually want full page text. Some providers return it inline, some sell it through a separate extract endpoint, and some do not offer it. This decides whether you need one API call or two per result.

Date and domain filters#

Agents often need "only from these sites" or "only after this date". Check which filters the provider applies natively and whether anything is enforced after the fact. Through Mux, domain filters are always enforced on the response as well, and published_before is not applied by Parallel models.

Rate limits#

A per-second ceiling that fits a single agent can collapse under a batch job. Look for the per-key and per-account numbers, what status code you get, and whether limited requests are billed. Mux allows 20 requests per second per key with bursts to 40, and 50 searches in flight per account. Limited requests return 429 with Retry-After and are never charged.

Failure handling#

Providers have outages and slow spells. The question is whether your agent degrades or stops. Retries inside an SDK help with transient errors. Falling back to a different provider helps with the rest. If you integrate one vendor directly, plan a second integration or accept the gap.

Per-agent budgets#

When many agents share one bill, you need a way to cap each one. Mux API keys carry an optional USD limit that resets daily, weekly or monthly, enforced atomically with the charge. A key over its limit gets 402 key_limit_exceeded and nothing is billed. Create one key per agent or per customer and set the limit when you create it. See /docs/keys.

Comparison on qualitative axes#

	Exa	Parallel	Keenable	Tavily	Brave Search API	Serper
Index	own neural index	own	own, pro and realtime	own	own independent index	Google results
Built for	semantic and research queries	agent search at low cost	flat-price search	agent frameworks, search plus extract and crawl	general search, grounding	Google SERP as JSON
Full page text	inline with `content: "full"`	excerpts	no	separate extract endpoint	no	no
Date filter	yes	after only	yes	yes	yes	via query operators
Domain filter	yes	yes	one native	yes	yes	via query operators
Max results per call	100	50	50	see docs	see docs	see docs
Via Mux	yes	yes	yes	no	no	no

Vendor sites: exa.ai, parallel.ai, keenable.ai, tavily.com, brave.com/search/api, serper.dev. Filter support for Tavily, Brave and Serper is as described in their public documentation, and details change, so confirm against their docs.

Published prices#

For the three providers Mux routes to, the prices below are the vendors' list prices as passed through by Mux. Each request includes 10 results. Extra results beyond 10 cost the extra rate per result, except on Keenable where they are free.

Model	Per 1,000 requests	Included results	Extra result	Latency
exa/instant Exa instant, lowest-latency neural search	$4.00	10	+$1.00 / 1k	~300 ms
exa/fast Exa fast	$7.00	10	+$1.00 / 1k	~500 ms
exa/auto Exa auto (default, best general quality)	$7.00	10	+$1.00 / 1k	~1 s
exa/deep Exa deep multi-query search	$12.00	10	+$1.00 / 1k	~5 s
parallel/turbo Parallel turbo, ~200ms	$1.00	10	+$1.00 / 1k	~200 ms
parallel/fast Parallel fast, <1s	$1.00	10	+$1.00 / 1k	~800 ms
parallel/basic Parallel basic	$5.00	10	+$1.00 / 1k	~1 s
parallel/advanced Parallel advanced, highest quality excerpts	$5.00	10	+$1.00 / 1k	~3 s
keenable/pro Keenable pro index	$4.00	10	none	~700 ms
keenable/realtime Keenable realtime index	$4.00	10	none	~700 ms

For the others, as of October 2026: Tavily's pricing page lists pay-as-you-go at $0.008 per credit, with a basic search costing 1 credit and an advanced search 2, so $8 or $16 per 1,000 searches at that rate, with monthly plans priced separately. Brave's API page lists its Search plan at $5 per 1,000 requests. Serper advertises 2,500 free queries on signup on its site and publishes volume tiers on its pricing page.

Worked example: 1,000 agent runs#

Assume a research agent that does four searches per run, 10 results each, and runs 1,000 times. That is 4,000 searches.

Setup	Per search	Per 1,000 runs
All `parallel/fast`	$0.001	$4.00
All `keenable/pro`	$0.004	$16.00
All `exa/auto`	$0.007	$28.00
3 × `parallel/fast` + 1 × `exa/auto` with `content: "full"`	$0.001 / $0.007	$10.00
All `exa/deep`	$0.012	$48.00

The mixed row is the usual shape: cheap lookups for discovery, one stronger search with full text when the agent has narrowed down what it wants. If the final step asks for 25 results on exa/auto, that call becomes $0.007 plus 15 × $0.001, or $0.022, and the row rises to $25.00.

Mux adds no per-request markup. Buying credits costs 5.5% of the purchase with a minimum of $0.80, so $50 buys $47.25 of credits and the mixed setup above runs about 4,700 times on that.

Here is the mixed setup as code:

import { Mux } from "getmux";

const mux = new Mux();

async function discover(q: string) {
  return mux.search({ query: q, models: ["parallel/fast", "keenable/pro"], maxResults: 10 });
}

async function readDeep(q: string, domains: string[]) {
  return mux.search({
    query: q,
    models: ["exa/auto", "parallel/advanced"],
    maxResults: 10,
    includeDomains: domains,
    content: "full",
  });
}

Every response carries usage.cost_usd, so you can log the real spend per run instead of estimating it.

Where Mux fits, and where it does not#

Mux is one key, one bill and one response shape across Exa, Parallel and Keenable, with ordered fallbacks, automatic refunds for failed attempts and per-key budgets. It fits when you want to compare providers without three integrations, or want failover without building it.

It is not a fit if the provider you want is Tavily, Brave, Serper or another vendor Mux does not route to, if you need a crawl or extract endpoint, or if you run one provider at a volume where a negotiated direct contract beats list price. In those cases go direct. With BYOK you can bring your own vendor key and keep Mux for routing.

FAQ#

What is the most important feature in a web search API for AI agents?#