Perplexity Search API pricing: what $5 and $1 per 1,000 actually buy
Perplexity's Search API costs $5 per 1,000 successful requests, or $1 per 1,000 with Fast Search. One request can carry up to five queries and still bills once. Failed and rate-limited requests are free, empty results are not, and there are no token charges. The old Sonar per-request fees no longer apply.
Short answer: For ranked pages with extracted text, use the Search API with search_type: "fast" at $1 per 1,000; use the Agent API only if Perplexity should write the answer. If you need Google or Bing positions, a specific country’s results page, or People Also Ask, use a SERP API such as Serpent API, from $0.03 per 1,000 — pay as you go, no subscription.
What does the Search API cost today?
On 20 November 2026 Perplexity's pricing page listed two prices for the Search API: $5.00 per 1,000 requests for standard search, and $1.00 per 1,000 with Fast Search. Both return the same response format. The page describes the product as "Ranked web results as JSON, with page text extracted into each result's snippet. No model, no generated answer, no token billing."
That last sentence is the important one. The Search API is not a chat model with search attached. It is a plain search endpoint, POST /search, and the bill is a flat fee per successful request. You do not pay for input or output tokens, because no model runs.
Perplexity sells the same search inside other products at different prices, which is where most of the confusion comes from:
| Product | What you get | Price | Tokens billed? |
|---|---|---|---|
| Search API, standard | Ranked pages with extracted text | $5.00 per 1,000 requests | No |
| Search API, Fast Search | Same format, lower latency | $1.00 per 1,000 requests | No |
Agent API web_search tool | A search the model runs while writing an answer | $2.50 per 1,000 calls ($1.00 with Fast Search) | Yes, model tokens on top |
| Context API | Content of URLs you already have | $1.00 per 1,000 fetched URLs | No, unless you send criteria |
perplexity/sonar model on the Agent API | A chat model | $0.25 input, $2.50 output per 1M tokens | Yes |
Fast Search arrived in September 2026; Perplexity's changelog gives the month but not the day. You turn it on with one field, search_type: "fast", and the Fast Search page notes that you need Python SDK 0.43.6 or TypeScript SDK 0.38.6 or later if you use the official clients.
What counts as one billable request?
One successful POST /search is one billing unit, whatever is inside it. The pricing page spells out the rule in a single paragraph, and every part of it changes your bill:
- Up to five queries count once. "A successful request containing an array of up to five queries is one billing unit." Send a list of five queries and you pay $0.005, or $0.001 with Fast Search, for all five.
- Failures are free. "Invalid requests, rate-limited requests, and upstream failures are not billed." A 429 costs nothing.
- Empty results are billed. "A successful response is billed even when it returns no results." A query that finds nothing still costs a request.
- No token charges. "There are no additional token-based charges."
Perplexity staff confirmed the five-query rule on the community forum in July 2026: "For the Search API a multi-query request is charged as one request ($0.005)."
There is a catch, and the Search API overview states it plainly. max_results "caps the combined results list across all queries, not each query, so some queries can contribute no results." With the standard and fast types, max_results tops out at 20. Five queries in one request therefore share at most 20 results, about four each on average, and the docs advise you to dedupe by URL before passing them to a model.
So packing is a real saving for broad research, where you want a few good pages from several angles. It is not a saving if you need ten results for each query; then you need separate requests and the price per query goes back to $5 or $1 per 1,000.
What will you pay at 1K, 100K and 1M queries?
At 100,000 queries a month, the Search API costs $500 on standard search, $100 with Fast Search, and as little as $20 if you pack five queries into every Fast request. The table puts those numbers next to the other search APIs developers usually compare it with.
Rules for the table: list prices on 20 November 2026, before any free monthly credit. One query is one search with default depth. Prepaid packs are counted as if you use the whole pack before it expires.
| Option | Per 1,000 queries | 1,000 a month | 100,000 a month | 1,000,000 a month |
|---|---|---|---|---|
| Perplexity Search API, standard | $5.00 | $5 | $500 | $5,000 |
| Perplexity Search API, Fast Search | $1.00 | $1 | $100 | $1,000 |
| Perplexity Fast, five queries per request | $0.20 | $0.20 | $20 | $200 |
| Tavily basic search, pay as you go (1 credit) | $8.00 | $8 | $800 | $8,000 |
Exa auto (10 results included) | $7.00 | $7 | $700 | $7,000 |
Exa lite | $4.00 | $4 | $400 | $4,000 |
| Brave Search API | $5.00 | $5 | $500 | $5,000 |
| Linkup standard | $5.00 | $5 | $500 | $5,000 |
Parallel fast | $1.00 | $1 | $100 | $1,000 |
| Serper (packs valid 6 months) | $1.00 to $0.50 | $1 (smallest pack $50) | $75 | $500 |
| Serpent API, Default | $0.60 | $0.60 | $60 | $600 |
| Serpent API, Growth ($100 deposit) | $0.30 | $0.30 | $30 | $300 |
| Serpent API, Scale ($500 deposit) | $0.10 | $0.10 | $10 | $100 |
| Serpent API, Enterprise ($1,000 deposit) | $0.05 | $0.05 | $5 | $50 |
| Serpent API, Enterprise Plus ($1,250 deposit) | $0.03 | $0.03 | $3 | $30 |
Prices come from each vendor's own page: Tavily, Exa, Brave, Linkup, Parallel, Serper and our pricing page.
Several of these vendors give some volume away. Tavily includes 1,000 free credits a month, Exa $10 of credit a month, Brave $5 a month and Serper 2,500 queries once. Perplexity's pricing page lists no free allowance; its quickstart mentions a sign-up credit without stating the amount, and an account that runs out gets 402 Payment Required, according to its FAQ.
Two cautions on reading the table. The products do not return the same thing, so a lower price only matters once the results are good enough for your job. And "per query" hides result depth: Perplexity returns up to 20 results per request, Exa includes 10, and one Serpent API call can ask for up to 100 organic results with num (a ceiling; Google calls often return 40 to 70).
What happened to Sonar pricing?
The Sonar chat models' per-request search fees are gone. Perplexity's migration guide says: "Sonar Chat Completions support ended on September 27, 2026." Synchronous and streaming Sonar requests keep working because they are being reformulated as Agent API requests, but asynchronous Sonar requests are no longer supported.
On 20 November 2026 the word "sonar" did not appear anywhere on Perplexity's pricing page. The only Sonar line left is the perplexity/sonar model on the Agent API models page, priced at $0.25 per million input tokens and $2.50 per million output tokens, with searches billed through the web_search tool.
That matters because most guides that rank for this query still print the old tables. For example, Puter's guide (updated June 2026) and Finout's (April 2026) list Sonar request fees of $5 to $12 per 1,000 and an Agent API search price of $0.005 a call. Today the same tool costs $0.0025, or $0.001 with Fast Search. Metronome's index (December 2025) quotes a "3 QPS rate limit"; the current docs say 50 query units per second.
If you built on Sonar and only used it to fetch sources, the Search API is the cheaper replacement: no model, no tokens, $1 per 1,000 with Fast Search. If you used Sonar for its written answers, the Agent API is the path Perplexity points to.
What do you get back for the money?
Each result carries a title, a url, a snippet, and, when known, a date and last_updated. The snippet is the valuable part: Perplexity describes it as "Query-relevant text extracted from the page. It is not the full page." The same page can return different text for different queries, because the extract is built for your query.
The request has useful controls, all documented in the API reference:
max_results: 1 to 20 for web and fast search, default 10.country: an ISO code that biases results toward that country.search_language_filter,search_domain_filter(up to 200 domains, with a minus sign to exclude) andsearch_recency_filter(hour, day, week, month or year).- Publication and last-updated date ranges.
What you do not get is a search engine's results page. The ranking is Perplexity's own, from its own web index, and there is no position on Google or Bing, no ads, no People Also Ask and no AI Overview. That is a design choice, not a flaw: the endpoint is built to feed text to a model.
Rate limits and usage tiers
The Search API allows 50 query units per second, with a burst of 50, on every account. Perplexity's rate-limit page says these limits "are independent of your usage tier", so spending more does not raise them.
Rate limits use a different unit from billing. A request with five queries is one billable request but five rate-limit units. In practice that means you can pack queries to save money, but not to get more throughput: 50 single queries per second and 10 five-query requests per second hit the same ceiling.
Usage tiers (from Tier 0 to Tier 5, based on lifetime purchases from $50 to $5,000) still exist, but they set limits for Perplexity's other APIs, such as the Agent API, not for search.
How does it compare with a SERP API?
The Perplexity Search API and a SERP API answer different questions. Perplexity's answers "which pages in our index best match this query, and what do they say". A SERP API answers "what does Google, or Bing, show for this query in this country right now".
If your agent needs page text to reason over, Perplexity's extracted snippets are a strong fit, and Fast Search at $1 per 1,000 is cheap for that job. If your product depends on the results page itself, you need a SERP API. Typical cases:
- Rank tracking and SEO work, where the
positionon a real engine is the data. See the rank tracking API. - Market-specific answers, where you set
countryandlanguagerather than bias toward them. Serpent API documents both under web search. - Results-page features such as People Also Ask, ads, related searches and AI Overviews, returned by the full web search endpoint.
- More than one engine: Google, Bing, Yahoo, DuckDuckGo and Brave on one key with the
engineparameter, listed under engines.
Serpent API's web search starts from $0.03 per 1,000 — pay as you go, no subscription; see pricing. For agents that read pages, the usual pattern is two steps: get the ranked results first, then fetch only the pages worth reading. Our guide to cutting LLM web search costs shows that pattern with numbers, and SERP API vs Tavily vs Exa explains the three families of search API in more depth.
If you want Perplexity-style answers but would rather own the pipeline, our tutorial on building your own answer engine walks through search, extraction and cited answers end to end.
Which option should you pick?
- Perplexity Search API with Fast Search if you want ranked pages with query-specific text for a prompt and a simple per-request bill. Start here before standard search; test whether standard's extra quality is worth five times the price on your own queries.
- Packed Fast requests for research agents that explore one topic from several angles and are happy with about four results per angle. At $0.20 per 1,000 queries, nothing in this comparison is cheaper per query.
- The Agent API if you want Perplexity to write the answer and cite sources. Budget model tokens on top of $1 to $2.50 per 1,000 searches.
- A SERP API if your product is about what people see on Google or Bing: positions, countries, languages and results-page features. Our overview of which LLM web search API fits your agent covers the wider choice.
How we checked this
On 20 November 2026 I read Perplexity's pricing page, Search API overview, API reference, Fast Search page, rate-limit page, Sonar migration guide, Agent API models page, changelog, quickstart and FAQ (10 official sources, read as raw Markdown from docs.perplexity.ai), one Perplexity staff answer on its community forum, the pricing pages of Tavily, Exa, Brave, Linkup, Parallel and Serper (6 vendor sources), our own pricing page and docs, and five ranking guides for the gap check. No requests were sent to any of these APIs for this post; every figure is a list price or a documented rule, and the cost table is arithmetic on those prices. What we could not verify: the exact day Fast Search launched (the changelog says only September 2026), and whether new accounts get a sign-up credit and how much.
Need results pages, not just pages?
Serpent API returns what Google, Bing, Yahoo, DuckDuckGo and Brave show, by country and language, from $0.03 per 1,000 — pay as you go, no subscription. Try it with 10 free API calls.
Get Your Free API KeyExplore: SERP API · Playground · Docs · Pricing
FAQ
How much does the Perplexity Search API cost per search?
A standard Search API request costs $0.005 ($5 per 1,000), and with Fast Search, set by search_type: "fast", it costs $0.001 ($1 per 1,000). Each request can hold up to five queries and is still billed once, so the cost per query can fall to $0.0002 with Fast Search. There are no token charges because no model runs; prices are from Perplexity's pricing page on 20 November 2026.
Is the Perplexity Search API free?
No free monthly allowance is listed on Perplexity's pricing page. The API is pay as you go with prepaid credit, and when the credit runs out requests return 402 Payment Required. The quickstart mentions a sign-up credit but does not give an amount, so check your billing page after you sign up. Failed requests, invalid requests and rate-limited requests are not billed, but a successful request with no results is.
What is Perplexity Fast Search?
Fast Search is a lower-latency search path that Perplexity added in September 2026. You turn it on with search_type: "fast" on the Search API or on the Agent API's web_search tool. It returns the same response format as standard search and costs $1 per 1,000 requests instead of $5; the official SDKs need Python 0.43.6 or TypeScript 0.38.6 or later. Test it on your own queries; whether standard search is worth five times the price depends on your use.
Is Perplexity Sonar retired?
Sonar Chat Completions support ended on 27 September 2026, according to Perplexity's migration guide. Synchronous and streaming Sonar requests still work because they are reformulated as Agent API requests, but asynchronous Sonar requests are no longer supported. The Sonar per-request search fees no longer appear on the pricing page. A perplexity/sonar model is still listed on the Agent API at $0.25 per million input tokens and $2.50 per million output tokens.
Does a multi-query request cost more?
No: up to five queries in one request are billed as one request, which Perplexity staff also confirmed on its forum. Two things change, though. The five queries share a single max_results limit of at most 20 results, so some queries may return nothing. And each query uses one rate-limit unit, so a five-query request counts as five against the 50-per-second limit.
What is the Perplexity Search API rate limit?
The Search API allows 50 query units per second with a burst of 50, the same on every account. A single-query request uses one unit and a multi-query request uses one unit per query. The limit does not rise with Perplexity's usage tiers, which apply to its other APIs. Rate-limited requests return 429 and are not billed, so a client that backs off and sends again later does not pay for the rejected attempts.
Sources
Perplexity official docs (checked 20 November 2026):
- Perplexity pricing (Search API, Fast Search, Agent API tools, Context API)
- Search API overview
- Search API reference (POST /search)
- Fast Search
- Rate limits and usage tiers
- Migrate from Sonar
- Agent API models
- Changelog
- Quickstart and FAQ
- Community forum: Search API pricing clarity (staff answer)
Other vendors' pricing (checked 20 November 2026):
- Tavily pricing and Tavily API credits
- Exa pricing
- Brave Search API
- Linkup pricing
- Parallel pricing
- Serper pricing
- Serpent API pricing
Guides compared in the gap check (read 20 November 2026):





