Your agent needs to answer a question whose answer changed this week — a price, a release, a ruling, a score. The model’s training data is a snapshot, so it either guesses or refuses. What it actually needs is to search the live web, read the top results, and ground the answer in current sources. This page shows the agent-native path to live search on a single Auxiliar key.
What the agent is trying to do
The agent has a concrete job: turn a question into a short list of relevant, current URLs and snippets it can reason over or fetch in full. It doesn’t want to run a crawler or build an index — it wants the same thing a person gets from a search box, in structured JSON.
That splits into a few real requirements:
- A live index — results reflecting the web now, not a months-old snapshot baked into the model.
- Relevance the agent can trust — the right pages near the top, ideally with a relevance score so it can threshold.
- A machine-shaped response — clean JSON (title, URL, snippet), not an HTML SERP it has to scrape.
- The right index for the job — raw Google grounding, an agent-native RAG index, or neural/semantic discovery are different tools, and the best one varies by query.
Why the agent cannot solve this alone
None of this is something an LLM can reason its way to — you cannot think your way to a fresh index. On its own, an agent cannot:
- Create or manage provider accounts — it can’t open a Serper, Tavily, or Exa account and agree to terms on a human’s behalf.
- Pass signup, payment, and bot flows — provider onboarding sits behind email verification, card entry, and its own bot gates that need a real human browser.
- Safely hold many upstream keys — stuffing a dozen provider secrets into an agent’s context or environment is a credential-sprawl and exfiltration risk.
- Know which index is winning right now — which search API has the best recall and lowest cost per useful result today is live measured data the model has no way to sample.
- Operate a search index — a crawled, ranked, deduplicated index of the web is infrastructure you buy, not a conclusion you reach by thinking harder.
So the blocker isn’t reasoning. Live search needs accounts, credentials, and current benchmark data — none of which live inside the model.
How Auxiliar solves it
Auxiliar is a web-access API gateway that collapses all of the above into one credential:
- One
AUXILIAR_API_KEY— the only secret the agent ever holds. - Upstream keys server-side — Serper, Tavily, Exa, Brave, You.com and the rest are authenticated by Auxiliar; the agent never sees a provider key.
- Native provider routes — call
https://api.auxiliar.ai/{provider}/{native-path}with the provider’s own request shape; existing SDKs and code keep working, you just change the base URL. - One balance — credit-metered against a single account, no per-provider subscriptions.
- Eval-backed selection — provider ranking comes from the Auxiliar curator fleet measuring recall, latency and cost per useful result on one shared query set, published at
/evals.jsonand the/best/pages. - One-line index swaps — because every search API is on the same key, the agent can start with the cheapest sufficient index and switch to a semantic or agent-native one when a query needs it, with no new signup.
First call
Start with the fastest, cheapest Google grounding — Serper — using your one key. The body is Serper’s own native shape; Auxiliar injects the Serper key server-side.
curl -X POST "https://api.auxiliar.ai/serper/search" \
-H "Authorization: Bearer $AUXILIAR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"q": "latest changes to the eu ai act"}'
A successful call returns HTTP 200 with structured Google results as JSON — organic links, snippets, and SERP features — ready to drop into a prompt or a fetch step. Serper scored quality 1.00 at $0.0003 / call and ~1.0 s on our SERP corpus; on the agent-search composite, Jina tops the ranking (recall@10 0.60, $0.00033 / useful result). See the full search ranking.
Fallback ladder
No single index wins every query. Start cheap and general, escalate by what the query needs — every provider below is on the same key, so switching is a one-line path change, not a new account. Values are measured by the Auxiliar curator fleet on one query set.
| Order | Provider | Reach for it when | Recall@10 | Cost / useful | Latency p50 |
|---|---|---|---|---|---|
| 1 | Serper | Default. Cheapest, fastest raw Google grounding; you synthesize. | 0.57 | $0.00053 | 1.5 s |
| 1 | Jina | You want clean markdown from a search-plus-read in one call; top composite. | 0.60 | $0.00033 | 1.4 s |
| 2 | Tavily | Agent/RAG default — relevance score and optional answer in one call. | 0.58 | $0.014 | 2.1 s |
| 2 | Exa | Semantic discovery, “find similar”, or a built-in /answer endpoint. |
0.61 | $0.014 | 1.6 s |
| 2 | Brave | An independent index that isn’t a Google/Bing scrape, plus privacy posture. | 0.64 | $0.0078 | 1.3 s |
| 3 | You.com | An independent index with domain-boosting and a cited Research API. | 0.65 | $0.0077 | 1.4 s |
| 3 | SearchAPI.io | SerpApi-compatible JSON at a lower price, pay-per-success. | 0.57 | $0.007 | 2.5 s |
| 3 | SerpApi | Compliance-sensitive, multi-engine breadth, or the LangChain default. | 0.59 | $0.015 | 2.8 s |
| 3 | DataForSEO | Bulk async SERP scraping, webhooks, the deepest SERP-feature taxonomy. | 0.59 | $0.0034 | 2.9 s |
| 3 | Linkup | A compliant SERP alternative with a built-in sourced answer. | 0.39 | $0.013 | 3.2 s |
The rule of thumb: Serper or Jina for cheap, high-recall grounding at volume; reach for Tavily / Exa when you want relevance scores, semantic discovery, or a cited answer bundled in.
Eval-backed, not marketing claims
Every number above comes from the Auxiliar curator fleet running each provider on the same query set — a merit-only ranking, not a listicle. Verify or route from the source:
- Best search API for AI agents — the full ranking with methodology.
- Cheapest search API — the same providers ranked by measured cost per useful result.
- Serper · Jina · Tavily · Exa — per-provider scorecards.
/evals.json— the machine-readable catalog + eval endpoint your agent (or theauxiliar-mcpserver) can read directly.
Optimizing for cost
Recall first, then squeeze cost — in that order:
- Start cheap and general. Route the default query to Serper or Jina; both deliver strong recall at a fraction of a cent per useful result. Reserve pricier indexes for queries that need them.
- Pay per useful result, not per call. Track
cost ÷ useful results, not raw request price — a cheap call that returns nothing relevant is the expensive one. - Escalate by need, not by default. Semantic discovery (Exa) and cited answers (You.com, Tavily) cost more; use them only when a query genuinely needs meaning-based recall or a bundled answer.
- Cap results. Request only the
kresults you’ll actually read; more results is more spend and more tokens downstream. - Downgrade once a cheaper index clears the bar. When a cheaper provider’s measured recall on your query mix crosses your threshold, make it the default and keep the richer one as fallback.
Because all indexes sit behind one key and one balance, this is routing logic in your agent — no renegotiated contracts, no new signups to change the mix.