Disclosure: This article contains no affiliate links. None of the three providers covered pays us a commission, so the rankings below are purely about price structure and fit. Where a tool is mentioned, it’s because it belongs in the comparison.
Every AI agent that answers questions about the real world has a hidden meter running: the search bill. Your agent doesn’t make one search per answer — it makes three, five, sometimes twenty, fanning out queries, reading pages, re-querying when the first results disappoint. Multiply that by thousands of user questions and the search API line item quietly becomes bigger than the model bill it feeds.
Three APIs dominate this layer in 2026: Tavily, Exa, and Perplexity’s Sonar family (plus its newer Search API). They all sell “search for AI,” but they meter it in three completely different currencies — credits, flat per-request fees, and tokens-plus-request-fees. This article converts all three into the only unit that matters for budgeting: cost per 1,000 queries — and then into cost per finished agent answer.
The three pricing models, translated
| Provider | Billing unit | Entry price per 1,000 standard queries | What else gets billed |
|---|---|---|---|
| Tavily | API credits (1 credit = basic search, 2 = advanced) | $5–$8 basic; $10–$16 advanced | Extract and Research draw from the same credit balance |
| Exa | Flat per-request fee by search type | $4 instant; $7 auto/fast; $12–$15 deep | $1 per 1,000 for each result above 10; Contents $1 per 1,000 pages |
| Perplexity Search API | Flat per-request fee | $5 ($1 on the Fast tier, per third-party trackers) | Nothing — no token charges on the raw Search API |
| Perplexity Sonar (answer models) | Tokens plus a per-request fee | $5–$14 per 1,000 requests in request fees alone | Input/output tokens on every call |
That last row is the trap. “Sonar” is not one product. The Search API returns raw ranked results at a flat $5 per 1,000 requests. The Sonar answer models (sonar, sonar-pro, sonar-reasoning-pro) return a synthesized, cited answer — and charge you twice for it: once in tokens, once in a request fee that scales with how wide a search context you request.
Tavily: the credit system, decoded
Tavily bills in credits, and the exchange rate depends on how you buy them. Pay-as-you-go credits cost $0.008 each; monthly plans bring the per-credit price down to $0.005 at the top tier. A basic search costs 1 credit; an advanced search (deeper retrieval, more sources) costs 2.
| Tavily plan | Monthly price | Credits/month | Per 1,000 basic searches | Per 1,000 advanced searches |
|---|---|---|---|---|
| Researcher (free) | $0 | 1,000 | Free up to 1,000 | Free up to 500 |
| Project | $30 | 4,000 | $7.50 | $15 |
| Bootstrap | $100 | 15,000 | $6.70 | $13.40 |
| Startup | $220 | 38,000 | $5.80 | $11.60 |
| Growth | $500 | 100,000 | $5 | $10 |
| Pay as you go | — | — | $8 | $16 |
Two things to know before the table seduces you. First, the same credit balance feeds Tavily’s other endpoints — Extract (1 credit per 5 URLs at basic depth, 2 at advanced) and the Research endpoint (priced per request at 4 to 250 credits). An agent that searches and extracts full pages burns one balance through two doors. Second, a documented gotcha: enabling auto_parameters can silently promote a basic search to advanced depth, doubling its cost. Nothing about the result tells you it happened — you find out on the invoice.
The free tier is genuinely useful: 1,000 credits a month, no card, resetting monthly. For a solo founder prototyping an agent, that’s a real runway.
Exa: flat fees, itemized extras
Exa — the neural search API that ranks pages by meaning rather than keyword match — prices by endpoint and search type:
| Exa endpoint | Price per 1,000 requests | Notes |
|---|---|---|
| Search (instant) | $4 | Fastest tier; up to 10 results with contents included |
| Search (auto/fast) | $7 | The standard production tier |
| Deep Search | $12 | Multi-step retrieval for harder queries |
| Deep-reasoning Search | $15 | Chains searches with reasoning between them |
| Answer | $5 | Direct Q&A instead of a result list |
| Contents (standalone) | $1 per 1,000 pages | Fetch full text for URLs you already have |
The extras are where Exa’s bill grows teeth. Each result above the included 10 adds $1 per 1,000 requests — an agent configured to pull 25 results per query pays meaningfully more than the headline rate suggests. Contents and summaries are separate meters. Third-party trackers note new accounts receive around $10 in monthly free credits, which softens prototyping but not production.
What you get for the money is the retrieval style: Exa’s index is built for semantic discovery (“companies doing X” rather than pages containing the word X), which is why research-style agents and lead-discovery tools gravitate to it. Whether that quality difference is worth $7 versus a $5 flat rival is a workload question, not a spec-sheet question — and it’s exactly why we model cost per answer, below.
Perplexity Sonar: two products wearing one name
The Search API is the simple one: a flat $5 per 1,000 requests for raw results (a $1 Fast tier appears in third-party pricing trackers), no token charges. If your agent does its own synthesis — most n8n and LangChain builds do — this is the apples-to-apples rival to Tavily basic and Exa auto.
The Sonar answer models are a different purchase:
| Model | Input / 1M tokens | Output / 1M tokens | Request fee per 1,000 (low / med / high context) |
|---|---|---|---|
| sonar | $1 | $1 | $5 / $8 / $12 |
| sonar-pro | $3 | $15 | $6 / $10 / $14 |
| sonar-reasoning-pro | $2 | $8 | $6 / $10 / $14 |
| sonar-deep-research | $2 | $8 | Billed per search instead — see the deep-research cost breakdown |
A worked example keeps this honest. A single sonar-pro answer with roughly 500 input and 200 output tokens at low context costs about $0.006 — the request fee, not the tokens, is most of the bill at small scale. Flip it around: at high context, the request fee alone is $14 per 1,000 calls before a single token is counted. Sonar is a fine product, but it is not a search API with a summary attached; it’s an answer engine, and it’s priced like one.
One transition worth knowing: Perplexity has been steering developers toward its newer Agent API, and third-party coverage reports support for the older Sonar chat-completions surface ended in September 2026. If you’re starting a build today, start on the current surface — don’t architect around a deprecated endpoint.
Cost per finished agent answer (the number that matters)
Nobody ships “1,000 queries.” You ship answers, and each answer fans out into multiple searches. Using a conservative, documented pattern — 3 searches per answer, reading 2 pages — here’s what the search layer costs per answer and per 100,000 answers a month:
| Stack | Search cost per answer | At 100,000 answers/month |
|---|---|---|
| Perplexity Search API (flat) ×3 | $0.015 | $1,500 |
| Exa auto ×3 (+ contents overage) | ~$0.021+ | ~$2,100+ |
| Tavily basic ×3 (pay-as-you-go) | $0.024 | $2,400 |
| Tavily advanced ×3 (pay-as-you-go) | $0.048 | $4,800 |
| Tavily advanced ×3 (Growth plan rate) | $0.030 | $3,000 |
Estimates built from the list prices above; your fan-out is the variable. An agent that runs 8 searches per answer roughly triples every row. This is the same “second meter” pattern we’ve documented for agent platforms generally in the true cost of AI agents: the headline unit price is small, the multiplier is your architecture.
Three budget rules fall out of the math:
- Cache aggressively. Agents re-ask near-identical questions constantly. A result cache in front of any of these APIs is the cheapest optimization in the stack.
- Route by difficulty. Instant/flat tiers for lookups, deep tiers for research queries only. Sending every query to a $12–$15 deep endpoint is a choice, not a requirement.
- Count results, not just requests. On Exa, result-count settings are a billing setting. On Tavily, depth settings are. Audit them like prices, because they are.
If you’re wiring one of these into an automation rather than a standalone app, our automated research pipeline in n8n shows where the search node sits in a production flow — and our citation trust test covers the separate problem of whether the answers these APIs return can actually be cited. For scraping-heavy workloads, the Apify vs Firecrawl vs Bright Data cost comparison prices the fetch side of the same stack.
FAQ
What is the cheapest search API for AI agents in 2026?
On list price per 1,000 standard queries: Exa’s instant tier ($4) and Perplexity’s Search API ($5) undercut Tavily’s pay-as-you-go basic search ($8). But “cheapest” depends on fan-out and extras — Exa charges for results above 10 per query, and Tavily’s committed plans drop basic search to $5 per 1,000. Model your cost per finished answer, not per query.
Is Perplexity Sonar the same as the Perplexity Search API?
No. The Search API returns raw results for a flat $5 per 1,000 requests with no token charges. The Sonar models return synthesized answers and bill tokens plus a per-request fee of $5–$14 per 1,000 calls depending on model and search-context size.
Why is my Tavily bill higher than the per-search price suggests?
Three usual causes: searches promoted to advanced depth (2 credits instead of 1 — the auto_parameters setting can do this silently), Extract calls drawing on the same credit balance, and Research-endpoint calls priced at 4–250 credits each.
Which search API is best for n8n or LangChain agents?
All three have official integrations in the major frameworks. The deciding factor is usually pricing shape: flat per-request (Exa, Perplexity Search API) is easiest to forecast; Tavily’s credits are cheapest at committed volume; Sonar answer models make sense only when you want Perplexity to do the synthesis too.
Do these APIs offer free tiers?
Tavily gives 1,000 free credits a month with no card. Exa gives new accounts roughly $10 in monthly credits per third-party trackers. Perplexity’s Search API has no standing free allowance documented; Pro subscribers receive a small monthly API credit ($5) that is separate from chat usage.
Methodology
What we did: Converted each provider’s published pricing — Tavily’s credit schedule, Exa’s per-endpoint rate card, Perplexity’s token-plus-request-fee tables and Search API flat rate — into cost per 1,000 queries and a modeled cost per finished agent answer, using a stated 3-searches-per-answer pattern sourced from published cost models. Prices cross-checked across vendor-documented figures as reported by multiple independent pricing trackers, October 2026.
What we did NOT do: We did not run benchmark queries, measure result quality, or test latency on any of the three APIs. No account was opened and no workload was replayed. Quality characterizations (e.g., Exa’s semantic ranking) describe each vendor’s documented design, not our test results. The per-answer figures are arithmetic on published list prices with stated assumptions — your fan-out, result counts and depth settings will move them.
Conflict disclosure: This article has no affiliate relationships to disclose for any provider covered.
AWL verdict
For most solo builders, the Perplexity Search API’s flat $5 per 1,000 requests is the easiest search bill to predict, Exa is the pick when semantic discovery quality is the point of the product, and Tavily wins at committed volume — provided you watch the depth settings that quietly double its per-query cost. Whichever you choose, budget per finished answer, not per query: your agent’s fan-out, not the rate card, decides the real bill.
Sources
- Tavily pricing structure, plan table and credit mechanics (via Parallel’s comparison, sourced from Tavily’s listed rates): https://parallel.ai/compare/tavily-vs-parallel (verified October 2026 — PAYG credit $0.008; basic search 1 credit; advanced 2 credits; plans $30–$500/mo)
- Exa and Tavily per-1,000 pricing, endpoints and free allowances: https://apicostcalc.com/web-search-api-cost-calculator.html (verified October 2026 — Exa search $7/1K, deep $12–$15/1K, contents $1/1K pages)
- Exa pricing detail and credit offers: https://apicostcalc.com/exa.html (verified October 2026 — reference prices July 2026, last verified 2026-10-20)
- Perplexity Sonar token rates and request fees by context size: https://cabina.ai/blog/perplexity-api-pricing/ (verified October 2026)
- Perplexity API structure — Search API flat $5/1K, Sonar request fees, deep-research add-on meters: https://www.finout.io/blog/perplexity-pricing-in-2026 (verified October 2026)
- Sonar Deep Research worked cost example (~$0.82 for one complex query): https://suprmind.ai/hub/perplexity/pricing/ (verified October 2026)
- Cross-provider per-1,000 table incl. Perplexity Search API and Exa (vendor pricing pages read October 2026): https://www.digitalapplied.com/blog/web-search-apis-for-ai-agents-compared-2026 (verified October 2026)
- Cost-per-answer model (3 searches, 2 page reads): https://openserp.dev/blog/web-search-api-for-ai-agents (verified October 2026)
