Exa 3.0 Search API Pricing and Limits in 2026
Oct 23, 202614 min read
Exa 3.0 is the new version of the search API from Exa, the company behind exa.ai, and we've read about it but not run it, much as we'd read about Activepieces before ever opening it.
New Exa 3.0 search API release
What Exa 3.0 is and who makes it
Aimed at programs rather than people, Exa's search API works like this: your code sends a query and gets web results back.
Before you write any code, four facts matter, and the table below ties each to the page that states it and the day we looked. Take it as a pointer to those pages, not a replacement for them.
| Fact | Value | Linked source | Checked |
|---|---|---|---|
| What it is | Version 3.0 of Exa's search API | exa.ai/blog/exa-3 | 2026-10-20 |
| Maker | Exa | exa.ai | 2026-10-20 |
| Release date | Given on the announcement post; read it there | exa.ai/blog/exa-3 | 2026-10-20 |
| Where to get a key | Through an Exa account; plan terms on the pricing page | exa.ai/pricing | 2026-10-20 |
Prices and plan limits checked against exa.ai and exa.ai and exa.ai and github.com on October 20, 2026.
Because the release date lives on the maker's post, a copy here would only age badly.
Whatever Exa's announcement claims is a claim, not a result we reproduced. It is the only place we take the date and the list of changes from, and we separate what's new in Exa 3.0 and what is still unconfirmed.
A release this young has no track record, so you can't assume any forum post, benchmark or wrapper is current. Check the commit history to see how recently it was touched.
Limits and prices here are read from the pricing page and docs, with the date we read them. If a figure here disagrees with those pages, the pages win.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Getting access and Exa API keys
Sign up for the Exa dashboard, finish onboarding, create a key, and send it from your server in a request header. The steps below follow exa.ai and its docs, so a page that has changed since we wrote this overrides them.
Creating an Exa account and API key
Skip a step and you lose free testing budget, because the onboarding credit comes from finishing onboarding, not from signing up. Take the amount from the page, not from here.
- Sign up for the dashboard on exa.ai.
- Finish onboarding, which is what earns the bonus credit.
- Create an API key from the dashboard.
- Store the key in a server-side environment variable.
- Send the key in the request header on every call.
Check the current API reference for the header name before you hardcode it, because a wrong header comes back as an authentication error, not a hint. The docs show the key in an x-api-key header.
Storing your Exa API key safely
Keep the key in a server-side variable and never in code that ships to a browser or app, since anything the client receives, a user can read. Your frontend should call your own endpoint, and that endpoint should call Exa.
Paste a key into client code and you'll have to revoke it, and Exa bills you for every request anyone makes with it until you do.
Before writing request code, open the dashboard and check three things. The onboarding credit should appear on your balance, the key you created should show as active, and your account should show its usage and limit information.
**Paste a key into client code and you'll have to revoke it, and Exa bills you for every request anyone makes with it until you do.
Whatever the dashboard shows is your working limit. Build your retry and error handling around that, and expect it to change.
Exa 3.0 endpoints and search types
You get three search types (Lite, Auto, Deep) in Exa 3.0. Only the search-type latencies are stated, so we mark everything else below unconfirmed until you check the docs.
Look at the table and you see how little the docs commit to: latency exists for the search types and nowhere else. Budget timeouts from those three numbers only, and measure the rest yourself.
| Name | What it does | Input | Output | Latency |
|---|---|---|---|---|
| /search | Finds pages | unconfirmed | unconfirmed | unconfirmed |
| /contents | Fetches page text | unconfirmed | unconfirmed | unconfirmed |
| /answer | Answers a question | unconfirmed | unconfirmed | unconfirmed |
| Lite | Search type | unconfirmed | unconfirmed | 450ms |
| Auto | Search type | unconfirmed | unconfirmed | 1s |
| Deep | Search type | unconfirmed | unconfirmed | ~10s |
Tune a timeout for one and it will kill the other: Deep is roughly twenty times slower than Lite.
Exa 3.0 agent effort levels and pricing
On the Exa pricing page, agent runs are priced by effort level. Minimal costs $0.012 per request, so a thousand runs is $12. Low costs $0.025, about double that.
At $0.10, Medium means a loop that retries blindly pays four times the Low price on every attempt. High costs $0.50, and X-high costs $1, roughly eighty-three times Minimal. A retry bug at X-high turns a hundred failed attempts into a $100 line item.
Behavior will keep shifting, because Exa announced 3.0 as its largest improvement to search quality. I can't confirm which limits or error codes the changelog lists.
Read it on the day you deploy, note its date, and cap retries per effort level so the expensive tiers fail fast.
Exa 3.0 pricing and rate limits
From $4 per 1,000 requests for Lite Search up to $15 for Monitors, that is the range Exa 3.0 charges. Search stops at 10 queries per second on the free tier, so the price you pay follows the effort level you cap.
Per-unit pricing
Read from Exa's pricing page and dated 2026-10-20, the table shows Lite as the cheapest endpoint, with Auto costing nearly double.
| Endpoint | Price per 1,000 requests | Rate limit | Source | Dated |
|---|---|---|---|---|
| Lite Search | $4 | 10 QPS | exa.ai/pricing | 2026-10-20 |
| Answer | $5 | — | exa.ai/pricing | 2026-10-20 |
| Auto Search | $7 | 10 QPS | exa.ai/pricing | 2026-10-20 |
If a retry loop escalates to Deep Search at $12, your Lite cost triples. Monitors are $15. Exa's free tier gives $10 in credits every month plus a $10 onboarding bonus, which is 2,500 Lite searches per $10, with no payment method required.
Against rivals, Exa Lite's $4 undercuts Brave, Perplexity and Parallel at $5 each and Tavily at $8, per Imisofts. That's a third-party comparison, so check it before you quote it.
Push past 10 QPS on search, and Exa stops you. Ten searches per second is 600 per minute, and a burst above that fails on the limit rather than on cost.
Multiply requests by price, then divide by 1,000. 200,000 Lite searches cost $800.
The same volume on Deep costs $2,400, so projects doing 200,000 searches will see a $1,600 cost difference between tiers. Recheck the pricing page on the day you deploy.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
A minimal working Exa 3.0 search request
It is one POST with your API key in a header and your query in a JSON body, and that request spends whatever quota the pricing page shows. Everything else is optional until the docs say otherwise.
Example Exa 3.0 search request with curl
This is the shape from Exa's documented search endpoint. We haven't run it against 3.0, so check the endpoint path, header name and body fields against the current docs before you copy it.
curl -X POST https://api.exa.ai/search \
-H "x-api-key: $EXA_API_KEY" \
-H "Content-Type: application/json" \
-d '{"query": "recent work on retrieval for coding agents"}'To keep the key out of your shell history and your logs, take it from an environment variable, not the command line.
Leave every optional parameter off for now. Each one you add is another field that 3.0 may have renamed, and a rejected request tells you less when you changed several things at once.
If you'd rather not hand-write that HTTP call, look in the open-source monorepo: Activepieces counts its 742 integrations directly from packages/pieces/community, part of the MIT-licensed core, so any Exa integration there has readable source and a commit history you can set against Exa's release date.
Reading the Exa 3.0 search response
On a successful call you should get JSON containing a list of results, each with at least a title and a URL. Treat that as the thing to confirm, not something to assume.
Print the raw body on your first call and read it before you write parsing code, because code written against a remembered schema fails quietly when a field moves.
If the call fails, save the full response, not just the status. The error body is where a limit or a rejected field would be named, and it's the only evidence you'll have when you ask support what happened.
Branch on the status class in your code, not on the message text, since the text is the part most likely to change.
Common Exa API errors and limits in production
If you want codes to branch on with confidence, there are three, all documented on Exa's error-codes page. Rate limits and timeouts below are general practice, not promises from the docs.
Below are the codes from exa.ai/docs/admin/error-codes. Each demands a different response, and trying again fixes none of them.
- 400, invalid request: your payload is wrong, so resending it repeats the failure. Fix the code and log the offending request.
- 401, key missing or invalid: the key never reached the request or was rejected, so a retry loop only delays the alert. Check the environment variable first.
- 402, credits exhausted or budget exceeded: the account is the problem, not the request, so every call fails until someone tops up or raises the budget.
Treat all three as non-retryable. On 402 especially, pause the queue and page a person, because a worker that keeps submitting jobs will fail every one of them.
Hitting rate limits
Read your actual limits on the pricing page and docs, where they may differ by plan. Since this section cites no rate-limit status code, discover the throttling response in testing and branch on its class, not its message.
Put a concurrency cap in front of the client so bursts wait in your queue instead of being rejected. When a throttle does arrive, back off with jitter so parallel workers don't retry in lockstep.
Exa API retries, caching and cost control
Set an explicit client timeout, then retry timeouts a small, bounded number of times with increasing delay. Search is a read, so repeating it is safe, but every repeat may be billed, so the cap protects your budget as much as the service.
Cache results for identical queries for as long as your use case tolerates stale answers. Every cache hit is a call you don't pay for and can't be throttled on.
Set your own spend ceiling below the account budget. That way you hit your alert before Exa returns a 402.
Call Exa 3.0 from Activepieces workflows
I can't point to a dated Activepieces release or announcement that targets Exa 3.0 specifically, so it can call Exa 3.0 only through what your instance has installed. Treat any claim of native support as unverified until you see it on your own instance.
Check installed integration versions
Check the Integrations page in admin settings, which lists every installed integration by display name, package name and version. The Version column is the useful one: an integration that hasn't moved since before Exa 3.0 was written against the older API.
So look for Exa in that list, and if it's absent or stale, assume its parameters and error handling don't match the 3.0 docs.
I have no confirmed release date or link to give you, and I won't guess one. Read the integration's changelog against Exa's own release date before you trust it.
If there's no current Exa integration, you can generate one with AI and add it privately to your own instance, with no public contribution needed.
You then own the request shape, which keeps you tied to the pricing page and docs rather than to someone's wrapper.
When a workflow beats raw API calls
When the work around the call matters more than the call, a workflow wins.
Take a scheduled research job that must retry on a rate-limit response, branch on a 402, and notify someone before the budget alert becomes an outage. It's easier to build and inspect as steps than as a script nobody owns.
It loses when you need tight control over each request. Latency-sensitive paths, heavy concurrency and custom backoff are all places where the step runner sits between you and the API. Write those as code, and use the workflow for scheduling, routing and alerting around them.
Frequently asked questions
Whatever you write is only as good as the figures it reads. I couldn't confirm any of them from an Exa page, so every answer here is tagged accordingly.
The list below covers the five numbers people ask about first; treat each "unconfirmed" as an instruction to open the page yourself before you build limits into anything.
- Free tier: $10 in credits every month plus a $10 onboarding bonus, no payment method required.
- Search rate limit: 10 QPS on the free tier and up to 25 QPS on pay as you go.
- Release date: Oct 19, 2026, per the announcement post.
- Cheapest search type: Lite, at $4 per 1,000 requests.
- Results per request: unconfirmed, so read the count from the response instead of hard-coding it.
Read that way, each answer below is a consequence of that gap.
Is there a free tier for the Exa 3.0 API? Yes: $10 in credits every month plus a $10 onboarding bonus, with no payment method required.
Does Exa 3.0 replace earlier Exa versions? Unconfirmed. Don't migrate on the assumption that the old version is retired, and don't assume it's safe forever either. Look for deprecation notices in the docs and pin the version you tested against.
Where do I recheck Exa's pricing and limits? On Exa's own pricing page and documentation, and nowhere else. Note the date you read them, because a figure from a blog post or a cached answer may predate a change.
Can I use Exa 3.0 without writing code? Unconfirmed as a native feature.
A workflow tool that can send an HTTP request can call the API, but whether Exa offers a dedicated no-code integration is something its docs have to tell you.
Even then, errors and limits reach you as raw responses, so you'll still need to handle them.
Related reading
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
