Perplexity API review
Best for raw search results at a flat request price
POST https://api.perplexity.ai/search Authorization: Bearer $PERPLEXITY_API_KEY # one request, up to five queries: billed once, $0.005 # rate limiter counts each query: 5 units of your 50 a second # search_type: "fast" drops it to $0.001
The Perplexity API is not one product any more, and the first thing to settle is which one a search for "Perplexity API" is actually about. The Search API returns ranked web results with titles, URLs and extracted text, and no generated answer, at $5 per 1,000 requests with no token costs. The Agent API runs models from OpenAI, Anthropic, Google, xAI and others, plus Perplexity's own, with web search priced as a tool call on top of the tokens.
The product most people mean by the name is Sonar, and Perplexity's migration guide says Sonar Chat Completions support ended on September 27, 2026. Synchronous and streaming requests keep working because they are being reformulated as Agent API requests, model by model, while asynchronous Sonar requests are no longer supported. An integration written against Sonar a year ago is now running on the Agent API whether it was migrated or not.
For a GTM pipeline that needs search results rather than prose, the Search API is the cleaner buy, and it has one billing detail worth knowing before the first line of code. Perplexity bills a request and rate limits a query, and a request can carry five queries.
The rest of the category is in the Sourcing APIs listing.
What a call costs, and which API it is on
Two price lists, because there are two products. The Search API is a flat price per successful request. The Agent API is model tokens at each model's published rate plus a fee every time a tool runs.
| Call | Price | Per call | Notes |
|---|---|---|---|
| Search API, standard | $5 per 1,000 | $0.005 | Ranked results and extracted text. No tokens billed. |
| Search API, fast | $1 per 1,000 | $0.001 | Set search_type: "fast". Lower latency. |
| Agent API web_search | $2.50 per 1,000 | $0.0025 | Per invocation, on top of the model's tokens. |
| Agent API web_search, fast | $1 per 1,000 | $0.001 | The same tool with the fast search type. |
| Agent API fetch_url | $0.50 per 1,000 | $0.0005 | Fetches and extracts a page you name. |
| Agent API people_search | $5 per 1,000 | $0.005 | Looks up professionals and employees. |
| Agent API sandbox | $0.03 a session | $0.03 | A 20-minute billing window per container. |
Perplexity's own example prices an Agent API call with 500 input tokens, 200 output tokens and one web search at $0.0059, of which the search is $0.0025. On the Search API the same lookup is $0.005 with no model at all, or $0.001 in fast mode. If all you want is results to hand to your own model, paying for a model inside Perplexity's is paying twice.
The Search API accepts an array of up to five queries in one request and bills it as one request, so five queries cost $0.005 together, $0.001 each. The rate limiter does not see it that way: each query in the array consumes one of the 50 query units you get a second. Perplexity says it plainly, billing and rate limiting use different units. Batch to save money, and expect to hit the limit at 10 batched requests a second rather than 50.
Perplexity API pricing, plan by plan
Perplexity API pricing is pay as you go from prepaid credits, with no subscription and no free tier, and the API you call decides the meter.
Search API
- Ranked results, titles, URLs and extracted text
- No token costs; up to five queries a request
- Invalid, rate-limited and failed requests are not billed
Search API, fast
- Set search_type to fast
- Lower latency, same billing unit
- The cheapest search Perplexity sells
Agent API
- Each model at its published input and output rate
- web_search $0.0025, fetch_url $0.0005 per call
- Replaces Sonar Chat Completions
Enterprise
- Custom pricing and dedicated support
- Credits also sold through AWS Marketplace
Credits are bought in advance. When the balance runs out, Perplexity blocks your API keys until you add more, and auto reload is the setting that tops the balance up when it drops below a threshold. Leave it off on an experimental key and a runaway loop stops at the balance; turn it on for anything in production, because a blocked key looks like an outage.
The same research question can cost $0.001 on the fast Search API or several cents through the Agent API with a large model and a few tool calls. Perplexity's pricing page reports a calculated cost on completed Agent API responses in usage.cost.total_cost, which is the field to log if you want to know what a run actually spent.
Perplexity API rate limits, by product and by tier
Perplexity API rate limits are set two ways. The Search API has one limit for everybody, 50 query units a second with a burst of 50, independent of your usage tier. The Agent API has tiered limits that rise with how much you have ever spent on credits, not with your current balance.
| Tier | Cumulative credits bought | Agent API requests | Agent API tokens a minute |
|---|---|---|---|
| Tier 0 | $0 | 1 QPS | 5,000,000 |
| Tier 1 | $50+ | 3 QPS | 6,000,000 |
| Tier 2 | $250+ | 8 QPS | 8,000,000 |
| Tier 3 | $500+ | 17 QPS | 10,000,000 |
| Tier 4 | $1,000+ | 33 QPS | 13,000,000 |
| Tier 5 | $5,000+ | 33 QPS | 16,000,000 |
An Agent API 429 can be the request limit (request_rate_limit_exceeded) or a token limit (token_rate_limit_exceeded), and you can hit the token limit while well under your requests per second, because both are shared across every key in the organization. A 429 carries Retry-After and is not billed. Successful Agent API responses carry x-ratelimit-remaining and x-ratelimit-reset.
For a search-heavy pipeline the Perplexity API rate limits that matter are the flat 50 query units a second, and no amount of spending moves them. For an agent-heavy one it is the tier, and Tier 0 at 1 request a second is low enough that a new account should buy $50 of credits before load testing anything.
How to create a Perplexity API key
Keys are created in the API console under a project, and every call sends one as a Bearer token. Billing sits at the same level, so the key and the balance it spends live together.
Before the first call
Two steps, and the second is the one people skip.
- Create an API key in the console.
- Add a payment method and buy credits; adding a card alone does not charge it.
- Decide on auto reload, because a zero balance blocks the key.
What the key reaches
One key, every API on the account.
- The Search API, the Agent API, Embeddings and the Decisions API.
- The hosted MCP server at api.perplexity.ai/mcp.
- Limits are shared across every key in the organization, so a second key adds no headroom.
Because limits and tokens are pooled across the organization, splitting work across several keys does nothing for throughput. Use separate keys to separate environments and to rotate safely, not to go faster.
A first Perplexity Search API call
This is the request from Perplexity's own Search API quickstart. The endpoint takes only the search parameters: model, effort and tools belong to the Agent API and are not part of a search request.
curl -X POST https://api.perplexity.ai/search \ -H "Authorization: Bearer $PERPLEXITY_API_KEY" \ -H "Content-Type: application/json" \ -d '{"query": "GPT-5.5 release announcement details", "max_results": 5}' # max_results accepts 1 to 20 and defaults to 10
Where the Perplexity API documentation lives
The Perplexity API docs live at docs.perplexity.ai, which publishes an llms.txt index and serves every page as Markdown with .md appended, so an agent can read them directly.
| Surface | Where | What it answers |
|---|---|---|
| Pricing | docs.perplexity.ai/getting-started/pricing | Search, Agent API tools, embeddings and decisions. |
| Rate limits | docs.perplexity.ai/docs/admin/rate-limits-usage-tiers | Tiers, QPS, token windows and the search limit. |
| Search quickstart | docs.perplexity.ai/docs/search/quickstart | The one endpoint and its parameters. |
| Sonar migration | docs.perplexity.ai/docs/agent-api/migrate-from-sonar/overview | What changed on September 27, 2026. |
| MCP server | api.perplexity.ai/mcp | Hosted over Streamable HTTP, or run locally over stdio. |
Read the Sonar migration page first if anything you run was built on Sonar, because the behavior changed under it without a code change on your side.
The MCP page lists Perplexity's MCP access alongside the others in this directory.
Perplexity on video
The section is here either way, because the absence is worth knowing: a vendor with no walkthrough of its own API is a vendor whose docs are the only way in.
We have not found a walkthrough of the API on Perplexity's own channel yet. Perplexity's API documentation links no YouTube channel, and its main site did not load for the harvester, so no channel could be proved to be Perplexity's own. A video from somebody else's channel about Perplexity is not a vendor video. When Perplexity publishes one, or sends us one, it goes here.
A vendor video is the vendor's claim about itself, which is why it sits in its own section.
Strengths and limits
The Search API is one of the simplest rate cards in this category, and the Agent API is the broadest model menu any search vendor here sells.
What it does well
- A flat $5 per 1,000 searches with no tokens, or $1 in fast mode.
- Up to five queries in one request, billed once.
- Failed, invalid and rate-limited requests are not billed.
- A hosted MCP server, plus a local one over stdio.
- The docs publish llms.txt and serve Markdown.
- The Agent API runs models from seven providers behind one key.
Where it falls short
- No free tier: credits first, and a zero balance blocks the key.
- Search is capped at 50 query units a second on every tier.
- Sonar support ended on September 27, 2026, and async Sonar no longer works.
- Agent API limits start at 1 request a second on a new account.
- Token and request limits are pooled across every key you hold.
- No contact data, so it complements an enrichment provider rather than replacing one.
Read together, the columns say the Search API is easy to price and hard to scale past 50 queries a second, and the Agent API is easy to scale and hard to price. Pick by whether you want results or answers, and keep the two bills apart.
Who should actually buy this
Buy the Perplexity Search API when a pipeline needs ranked web results and the text behind them, and you would rather pay a flat $0.005 a request than meter tokens. Batch up to five queries per request to bring that to $0.001 a query, and size your throughput on 10 batched requests a second, not 50.
Use the Agent API when you want Perplexity to run the model as well, and accept that the bill is now tokens plus tools. If you have a Sonar integration, treat this page as the notice: it is already running on the Agent API, and async calls have stopped working.
Against Exa and Tavily, Perplexity has the flattest search price and no free tier. Exa and Tavily both let you test on free credits, so run the same fifty queries through all three before you buy any of them, and compare the results rather than the rate cards.
Before you build against it
Five things to settle first, each one read off Perplexity's own pages. The ticks are remembered in this browser, so you can come back to a half-finished integration.
Where the data comes from, and what you may do with it
The question that arrives late and expensively is who is allowed to hold the data. These are the fields it returns, the coverage it claims and the compliance it publishes.
| Provider | Fields returned | Coverage | Compliance | Redistribution |
|---|---|---|---|---|
| Perplexity | Intent and news, Web pages | Global | None published | Not stated |
Perplexity states no redistribution position on its pricing or docs pages. Internally that never matters. Put the rows in something your customers can see and it becomes the question your legal team asks first.
Two practical notes. A compliance badge describes the vendor rather than your use of it, so a GDPR DPA does not give you a lawful basis for the outreach you send. And the vendor runs its own opt-out, which means a person who asks you to delete their record has to be removed from your copy as well as from theirs.
If Perplexity is not the answer
Four providers in the Sourcing APIs listing that solve the same problem differently. Each one is a trade, and the trade is named.
Exa
$4/1k searchesThe closest like-for-like: ranked pages with the text extracted, $4 to $15 per 1,000 by mode, and $10 of free credits a month.
Parallel
$1/1k searchesPer request, never per token: $1 per 1,000 searches in fast mode, $5 of free credits a month, and a Task API for structured research.
Tavily
$0.008/creditA free tier of 1,000 credits a month with no card, and one credit a basic search at $0.008 on pay as you go.
Serper
$1/1k queriesIf what you wanted was Google results as JSON: $1 per 1,000 queries on the Starter pack, falling to $0.30, and 2,500 free queries.
The full set, organized by the reason people leave, is on the Perplexity alternatives page.
Perplexity against the obvious rival
Same rate cards, read side by side, with the arithmetic done on a worked volume rather than left to you: Exa vs Perplexity. Every pairing in the directory is on the compare hub.
Calling these APIs one by one? Run them from one Clay table.
Clay runs a waterfall across 150+ data providers from one table, without a separate contract with each. A lookup that finds nothing costs no data credit, and the free plan includes 500 actions a month.
Frontal is a Clay Elite Studio Partner.
Nothing worth quoting yet
We searched Reddit for threads about the Perplexity API and have found none worth quoting yet. When one turns up, it goes here, and nothing on this page leans on an unquoted paraphrase.
Perplexity API, answered
Is the Perplexity API free?
No free tier. Credits are bought in advance, and keys are blocked at a zero balance unless auto reload is on. Paid plans start at $5/1k searches.
How much does the Perplexity API cost?
Perplexity starts at $5/1k searches. Its unit rate is $0.005 per search request. It bills pay as you go or by credit pack. Read from Perplexity's own pricing page on 24 October 2026.
What are the Perplexity API rate limits?
Search 50 query units a second on every tier. Agent API 1 to 33 QPS by spend tier.
How do I get a Perplexity API key?
Keys are created in the API console under a project, and every call sends one as a Bearer token. Requests authenticate with bearer API key from the API console. The current steps are in Perplexity's own documentation, which is authoritative on anything that has changed since 24 October 2026.
Does Perplexity have an MCP server?
Yes, at https://api.perplexity.ai/mcp. It is listed with the others on the MCP page.