Perplexity API Pricing: Search, Sonar, Agent and Embeddings Costs
Perplexity API pricing is pay as you go, but each API uses a different billing formula. Compare current request fees, token rates and tool charges before choosing the cheapest reliable route for your application.
Prices are shown in US dollars and can change. Confirm the live rate before approving a production budget.
How much does the Perplexity API cost?
There is no single Perplexity API price. The total depends on whether you need raw web results, a cited answer, an agent using tools, model routing or vector embeddings.
Search API
$5 per 1,000Charged per successful search request. Up to five queries can be included in one request, with no extra token charge.
Sonar API
Tokens + request feeToken prices vary by Sonar model. Sonar, Pro and Reasoning Pro also add a fee based on search context size.
Agent API
Model + toolsThird-party models are billed at their listed token rates without Perplexity markup; tool invocations are charged separately.
Embeddings
From $0.004 / 1MPricing is based on tokens embedded. Standard and contextualised models have different dimensions and rates.
How Perplexity API billing works
The developer platform uses prepaid API credits rather than a fixed monthly consumer subscription. Costs are attributed to the API group and its keys.
Create an API group
The group is the billing workspace for payment methods, keys, members, credit balance, invoices and usage reporting.
Purchase credits in advance
API requests use the available credit balance. Adding a payment card alone does not create a charge; credits are purchased when needed.
Enable auto reload if required
An automatic top-up can reduce outages by adding credits when the balance drops below the threshold configured in Billing.
Monitor actual usage
Review costs in the Console and log the cost fields returned by supported endpoints. Do not estimate production spend from request count alone when tokens or tools are involved.
Perplexity API pricing calculator
Estimate Search API or standard Sonar costs from expected request volume and average token use. The calculator uses the published August 2026 rates on this page.
For Search API, token fields and context are ignored. Deep Research is excluded because citation, reasoning and automatically selected search-query charges vary by run.
Planning estimate only. It excludes tax, infrastructure, retries, Deep Research components and future price changes.
Current Sonar API token pricing
Sonar models generate web-grounded answers. Their token rates are charged per one million tokens, while selected models also carry a per-request search-context fee.
| Sonar model | Input / 1M | Output / 1M | Citation / 1M | Searches / 1K | Reasoning / 1M |
|---|---|---|---|---|---|
| Sonar | $1 | $1 | β | β | β |
| Sonar Pro | $3 | $15 | β | β | β |
| Sonar Reasoning Pro | $2 | $8 | β | β | β |
| Sonar Deep Research | $2 | $8 | $2 | $5 | $3 |
Sonar request fees by context size
For Sonar, Sonar Pro and Sonar Reasoning Pro, add the relevant request fee to the token cost. Low context is the default and cheapest; high context retrieves more web information.
| Model | Low context / 1K | Medium context / 1K | High context / 1K | Token charge also applies? |
|---|---|---|---|---|
| Sonar | $5 | $8 | $12 | Yes |
| Sonar Pro | $6 | $10 | $14 | Yes |
| Sonar Reasoning Pro | $6 | $10 | $14 | Yes |
Sonar cost formula
Convert each token count to a fraction of one million, multiply it by that modelβs rate, then add the context request fee.
+ Context request fee
Worked Sonar example
Illustrative 1,000 low-context Sonar calls averaging 500 input tokens and 300 output tokens each.
Sonar Pro Search pricing
Pro Search lets Sonar Pro use multiple searches and URL fetching for complex questions. The token rates remain $3 per million input tokens and $15 per million output tokens.
| Search type | Low context / 1K | Medium context / 1K | High context / 1K | Best suited to |
|---|---|---|---|---|
fast | $6 | $10 | $14 | Standard, straightforward queries |
pro | $14 | $18 | $22 | Complex, multi-step research |
auto | Charged according to fast or pro classification | Mixed workloads | ||
Agent API and Search API pricing
The Agent API combines model consumption with optional tools. The Search API is simpler: it returns raw ranked web results for a fixed request charge.
Agent API: model cost plus tools
Third-party models are billed at their published token rates without Perplexity markup. Model prices vary and are updated monthly, so the live Agent model catalogue is the authoritative rate card.
web_search$0.0025 / invocationfetch_url$0.0005 / invocationpeople_search$0.005 / invocationfinance_search$0.005 / invocationsandbox$0.03 / sessionSearch API: $5 per 1,000 requests
Search API billing is based on each successful POST /search request. A request may contain an array of up to five queries and still count as one billing unit. There is no added token charge.
1,000 successful requests$510,000 successful requests$50100,000 successful requests$500Perplexity Embeddings API pricing
Embeddings turn text into vectors for semantic search, clustering and retrieval-augmented generation. Charges are based only on the number of tokens processed.
| Embedding model | Type | Dimensions | Price per 1M tokens | Typical use |
|---|---|---|---|---|
pplx-embed-v1-0.6b | Standard | 1,024 | $0.004 | Large-scale economical indexing |
pplx-embed-v1-4b | Standard | 2,560 | $0.03 | Higher-capacity vector representation |
pplx-embed-context-v1-0.6b | Contextualised | 1,024 | $0.008 | Documents needing surrounding context |
pplx-embed-context-v1-4b | Contextualised | 2,560 | $0.05 | High-detail contextual retrieval |
Perplexity API cost examples
These scenarios show how small changes in the model, output length and search depth can change the monthly total. They are estimates, not quotes.
Raw search monitoring
$5010,000 successful Search API requests, with no token-based charge.
Useful for collecting ranked results that your own application will filter or analyse.1,000 basic Sonar answers
About $5.80Low context, with an average of 500 input and 300 output tokens per request.
Calculation: $0.50 input + $0.30 output + $5 low-context request fees.1,000 Sonar Pro answers
About $12The same assumed token volume using Sonar Pro and the low-context fast-search fee.
Calculation: $1.50 input + $4.50 output + $6 request fees.1M standard embeddings
From $0.004Using the 0.6B standard embedding model for economical bulk indexing.
Vector database, storage and application hosting charges are separate.1,000 Agent searches
$2.50 + modelOne web_search invocation per Agent request, before input and output token charges.
Extra searches, URL fetches or specialist tools increase the total.Deep Research workload
VariableInput, output, citation, reasoning and automatically selected search-query usage may all apply.
Run a representative sample and record real cost fields before forecasting at scale.Perplexity API usage tiers
Usage tiers are based on cumulative API credits purchased across the accountβs lifetime. Higher tiers mainly increase rate limits and access; they do not represent a reduced token price.
How to reduce Perplexity API costs
The best savings come from matching the API to the task, constraining unnecessary output and measuring real production behaviour.
Choose the simplest API
Use Search for raw results, Sonar for a cited answer, Agent for multi-step tool use and Embeddings for retrieval. Do not pay for generation when ranked links are enough.
Route by task difficulty
Use lower-cost models or presets for classification and routine lookups. Reserve deeper reasoning and Pro Search for work that benefits from them.
Limit response length
Concise prompts, sensible output caps and structured formats can prevent unnecessary output tokens without weakening the result.
Start with low context
Low search context is the default and cheapest. Move to medium or high only when testing shows that extra retrieval improves accuracy or coverage.
Cache safe repeat work
Cache non-sensitive results whose freshness requirements permit reuse. Set expiry rules so old prices, news or rankings are not served indefinitely.
Log cost by workflow
Record usage, the selected model, tool calls and returned cost data. Set alerts and separate keys so one experimental job cannot silently consume the whole budget.
Which Perplexity API is best for SEO tasks?
Start with the output your workflow genuinely needs. Cost, accuracy and review requirements differ between monitoring, research and automated drafting.
Search monitoring
Start with Search API. It suits collecting raw results, source URLs and recurring query sets for your own analysis.
Publisher research
Start with Sonar. A web-grounded answer with citations is useful when researching sites, sectors and recent developments.
Complex market report
Test Deep Research. Use it selectively for questions that justify multiple searches, reasoning and longer synthesis.
Internal knowledge search
Use Embeddings. Index approved documents, publisher notes or editorial guidance for semantic retrieval.
Perplexity API pricing questions
Direct answers about free access, subscriptions, Search billing, context fees and budgeting.
Is the Perplexity API free?
Perplexity describes its APIs as pay as you go and says no subscription is required. New accounts may have limited Tier 0 access, but production use requires API credit and should be budgeted against the current rate card.
Does Perplexity Pro include API credit?
No. Consumer subscriptions and developer API billing are separate. Create an API group, add billing and purchase credits independently.
How much is the Perplexity Search API?
The current price is $5 per 1,000 successful POST /search requests. There are no additional token charges, and one request can contain up to five queries while remaining one billing unit.
Why does Sonar have token and request fees?
Token charges cover the text processed and generated, while the request fee reflects the selected search-context depth. Low, medium and high context retrieve different amounts of web information.
Are failed requests charged?
For the Search API, Perplexity says invalid, rate-limited and upstream-failed requests are not billed. A successful response is billed even when it contains no results. Requests rejected with a 429 are also described as not billed.
How can I estimate a monthly Perplexity API budget?
Run a representative sample, measure average input and output tokens, request fees and tool invocations, then multiply by expected volume. Add a contingency for unusually long responses, retries and workload growth.
Do higher usage tiers reduce the API price?
The published tier documentation describes increased rate limits and access rather than discounted token prices. Tiers are determined by cumulative API credit purchases.
Choose the billing model before choosing the model
Start with the simplest API that produces the required output, test it on real workloads and monitor cost per successful SEO or research taskβnot merely cost per request.
