Exa vs Perplexity API for AI Agents: Retrieval Modes, Answers, and Pricing

TLDR: Exa and Perplexity sell different primitives. Exa's search returns ranked pages with excerpts or full text in one call, offers six search types from instant at $4 per 1,000 requests to deep-reasoning at $15, and can synthesize an answer with outputSchema. Perplexity's Search API returns ranked snippets at $5.00 per 1,000 requests, or $1.00 with Fast Search, and sends answers to its Agent API. Choose Exa for filtered discovery and Perplexity for cheap raw volume.

Both vendors sell web search to AI developers and both can hand back page text, so the comparison usually starts as a price question. Start with the shape of the call instead, because it decides where synthesis happens, how much a result costs, and how you detect failure. Every figure below comes from vendor documentation, accurate as of October 2026, and is linked where it is used. Prices and limits change, so re-check the linked page before you commit.

What Does Each API Return?

Exa's search endpoint is POST https://api.exa.ai/search, authenticated with an Authorization: Bearer header or x-api-key. Only query is required. Results come back ranked, each with an id, title, URL, and publication date when known, plus whatever you request under contents: highlights (query-relevant excerpts, which Exa recommends for most tasks), full text, or an AI summary. numResults accepts 1 to 100 with a default of 10, and Exa notes that search does not support pagination. Add outputSchema and Exa synthesizes a text or JSON answer on top of the ranked pages, returned in output.content with field-level sources and confidence in output.grounding.

Perplexity's Search API is POST https://api.perplexity.ai/search. Each result carries a title, a URL, a snippet of content extracted from the page, and optional date and last_updated fields. max_results goes up to 20, one request can carry up to five queries, and max_tokens and max_tokens_per_page budget how much page content comes back. Synthesis is a separate product: Perplexity's guidance is to use the Search API for raw results and the Agent API for an answer with citations.

	Exa Search	Perplexity Search API
Page content in the same call	Highlights, full text, or summary per result	Page-extracted snippet, sized by token budgets
Synthesized answer in the same call	Yes, with outputSchema and in the deep search types	No. Use the Agent API
Results per request	Up to 100	Up to 20
Queries per request	One	Up to five
Domain filters	includeDomains and excludeDomains, up to 1,200 entries each, with wildcard subdomains and path prefixes	search_domain_filter, up to 20, allowlist or denylist but not both
Source focus	category: company, people, news, publication, personal site, financial report	search_type of people, plus domain filters
Date filters	startPublishedDate and endPublishedDate	Recency filter from hour to year, plus date ranges

Sources: Exa's OpenAPI spec and the Perplexity Search API reference. One Exa gotcha is documented in the spec: the company and people categories do not support startPublishedDate, endPublishedDate, or excludeDomains, and using them returns a 400.

What Are Exa's Search Types, and What Does Perplexity Offer Instead?

Exa's current reference lists six type values, and the older neural-versus-keyword framing is not among them. The default is auto. Latency figures are Exa's approximate numbers for the search itself with cached content.

Exa type	Typical latency	Price per 1,000 requests, up to 10 results
instant	About 250 ms	$4
fast	About 450 ms	$7
auto (default)	About 1 second	$7
deep-lite	About 4 seconds	$12
deep	4 to 15 seconds	$12
deep-reasoning	12 to 40 seconds	$15

The deep types run a research process with synthesis rather than a single retrieval pass, and Exa points long-running research to its Agent product instead of deep-reasoning. Exa's own tuning advice is to change the search mode last, after the query and any hard filters, and it recommends the deep types when you use outputSchema, so a synthesized answer from search starts at $12 per 1,000 requests. Perplexity's Search API has far fewer modes: web by default, fast for lower latency and cost, and people. Depth lives in the Agent API instead, which Perplexity organizes as presets from fast through xhigh. The practical difference is where the dial sits. With Exa you raise depth on the same endpoint and pay a higher per-request price. With Perplexity you stay on a flat-priced search and move to a token-billed agent when you need reasoning.

How Do the Costs Compare?

Exa's pricing page gives each request a base price that covers up to 10 results. Every result above 10 adds $1 per 1,000 results, and an AI page summary adds $1 per 1,000 pages. Exa's best-practices page adds that highlights, text, and summary can be combined in one request, but each view is billed separately, so request one view unless the task needs more. Perplexity's pricing page bills one unit per successful request, $5.00 per 1,000 or $1.00 per 1,000 with search_type set to fast, with no token charges on the Search API. The script prices both.

"""Monthly search cost: Exa search types vs Perplexity Search API (list prices, October 2026)."""

EXA_BASE_PER_1K = {          # per 1,000 requests, up to 10 results included
    "instant": 4.00,
    "fast": 7.00,
    "auto": 7.00,
    "deep-lite": 12.00,
    "deep": 12.00,
    "deep-reasoning": 15.00,
}
EXA_EXTRA_RESULT_PER_1K = 1.00   # per 1,000 results above ten
EXA_SUMMARY_PER_1K = 1.00        # per 1,000 pages with an AI summary
PPLX_PER_1K = {"web": 5.00, "fast": 1.00}   # per 1,000 successful requests


def exa_monthly(searches, search_type="auto", results=10, summaries=False):
    """Search charge only. Extra content views and the Answer endpoint bill separately."""
    per_1k_requests = EXA_BASE_PER_1K[search_type]
    per_1k_requests += max(0, results - 10) * EXA_EXTRA_RESULT_PER_1K
    if summaries:
        per_1k_requests += results * EXA_SUMMARY_PER_1K
    return searches / 1000 * per_1k_requests


def perplexity_monthly(searches, search_type="web"):
    """One billing unit per successful request, whatever the result count (up to 20)."""
    return searches / 1000 * PPLX_PER_1K[search_type]


if __name__ == "__main__":
    n = 50000
    for t in ("instant", "auto", "deep", "deep-reasoning"):
        print("Exa %-14s 10 results: $%.2f" % (t, exa_monthly(n, t)))
    print("Exa auto, 20 results: $%.2f" % exa_monthly(n, "auto", results=20))
    print("Exa auto, 10 summaries: $%.2f" % exa_monthly(n, "auto", summaries=True))
    print("Perplexity web: $%.2f" % perplexity_monthly(n))
    print("Perplexity fast: $%.2f" % perplexity_monthly(n, "fast"))

At 50,000 searches a month with 10 results each, Exa costs $200 on instant, $350 on auto, $600 on deep, and $750 on deep-reasoning. Perplexity costs $250 on standard search and $50 with Fast Search. The result count changes Exa's bill and not Perplexity's. At 20 results per request, auto rises to $850 because ten extra results per request add $10 per 1,000 requests. Asking for an AI summary on each of 10 results adds the same $10, more than the $7 base price of the search.

Exa credits $10 on sign-up and resets the balance to $10 on the first of each month without accumulating, which it says covers up to 2,500 Instant searches. For answers, Exa's Answer endpoint is $5 per 1,000 requests and its Agent is $0.012 to $1.00 per fixed-effort run, while Perplexity's Agent API charges model tokens plus tool fees, such as $0.0025 per standard web search.

What Limits and Failure Signals Matter?

	Exa	Perplexity
Default throughput	10 queries per second on search, 5 on the deep types. Adding $1,000 in credits within 30 days raises it to 25 for 90 days	Search API: 50 query units per second, independent of usage tier
Rate limited	429, with Retry-After when present	429
Out of money	402, with tags NO_MORE_CREDITS, API_KEY_BUDGET_EXCEEDED, and TEAM_BUDGET_EXCEEDED	401, the same code as an invalid key
Overload	503 SERVICE_OVERLOADED, not billed. Retry with backoff	Upstream failures are not billed

Sources: Exa's billing and rate limits page and error codes, and Perplexity's rate limits page and FAQ.

The out-of-money row is the one to design for. Exa uses the semantically right code: 402 means credits or a spending budget ran out, so your handler can page a human and stop retrying. Exa also offers auto recharge, which buys credits when the balance reaches a threshold you set. Perplexity's 401 looks like a bad key on the wire, and its FAQ says the code also means the account ran out of credits, so check the balance before you rotate keys and turn on auto top-up. Branch on the HTTP status first. Exa says unrecognized tags should be treated as extra detail, not parse failures.

Throughput is the other asymmetry. A default Exa account serves 10 queries per second and Perplexity's Search API serves 50 query units per second, so a fan-out agent that issues many sub-queries will hit Exa's ceiling first. Remember that Perplexity counts every query in a multi-query request as a unit, even though the request bills once. One SDK note from Perplexity's Fast Search page: on Python library versions 0.43.4 and 0.43.5, passing search_type="fast" directly fails validation, and the documented workaround is extra_body={"search_type": "fast"}.

How Do Data Handling Terms Compare?

Perplexity's FAQ says it does not retain query data sent through the API, does not train on it, and applies zero-day retention of user prompt data by default. It lists a SOC 2 Type II report. Exa makes Zero Data Retention available on Enterprise plans, enabled per team, for Search, Contents, Agent, and Answer, and offers HIPAA compliance to eligible Enterprise customers. A FAQ statement is not a contract term, so confirm retention, training, and subprocessor language in your agreement before you send sensitive queries to either.

Which One Fits Which Job?

If your agent needs	Lean toward	Why
Pages found by description, with category filters or very long domain lists	Exa	category, up to 1,200 domain entries, and content in the same call
High-volume raw lookups where cost per call dominates	Perplexity Search with Fast Search	$1.00 per 1,000 requests and 50 query units per second
A real-time path such as voice or autocomplete	Exa instant	Exa lists about 250 ms typical latency for it
A synthesized, cited answer	Either, as separate products	Exa outputSchema, Answer, or Agent. Perplexity Agent API
A clean billing signal when funds run out	Exa	402 with explicit tags, versus Perplexity's overloaded 401

Cost, quality, and latency in that table come from documentation, not from your queries. Only your query set can settle the quality column.

Where Does You.com Fit?

The You.com Web Search API is a results API like both of these. It is POST https://ydc-index.io/v1/search with an X-API-Key header, priced at $5.00 per 1,000 calls with up to 100 results per call, and it takes include_domains up to 500 domains and exclude_domains up to 5,000. Self-serve accounts default to 10 requests per second, the same as Exa's default, and higher limits come with a custom plan. For a direct comparison with Exa, see our You.com vs Exa guide. For Exa's price structure in depth, see the Exa pricing guide, and for switching away from Exa, see Exa alternatives. Our You.com Web Search API guide covers the endpoint, pricing, and limits.

What Should You Test Before You Choose?

1. Replay 50 real queries through each Exa type you might use and through Perplexity's two search types, and log result count, latency, and the newest date returned.
2. Price the content view, not just the search. Run the same queries with Exa highlights, then text, and compare the tokens your model receives per answer.
3. Exercise the category filters you plan to use, including the 400 that Exa returns for date filters on company and people.
4. Mock 402, 401, 429, and 503 and assert that your client stops and alerts on the first two and backs off on the last two.
5. Fire a burst equal to your peak sub-query fan-out and compare it with 10 queries per second on Exa and 50 units per second on Perplexity.

Our web search APIs for AI agents guide covers the wider field, and our Perplexity API alternatives guide covers the Sonar migration.

Related Guides

• 5 Exa Alternatives: Costs, Outputs and Migration
• Exa Pricing Explained: Costs and Alternatives
• 5 Perplexity API Alternatives for 2026
• Tavily vs Exa: AI Search APIs Compared (2026)