Recommended Free Tools
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Perplexity Search API is a developer-facing web-retrieval service, not simply the company’s consumer answer engine exposed through an endpoint. It returns ranked, structured web results and extracted content that developers can feed into their own RAG pipelines, agents, search products, rerankers, and language models.
The distinction matters. Perplexity’s current documentation positions Search API for raw retrieval, while the Agent API is intended for generated, web-grounded answers with citations. Search API costs $5 per 1,000 successful requests, with no additional Search token charge according to Perplexity’s current pricing documentation.
The short version
Perplexity launched its Search API on September 26, 2025, as part of a broader move from consumer-facing AI answers toward developer infrastructure. The service gives applications access to real-time, ranked web results, filtering, multi-query search, and extracted page content through REST, cURL, Python, and TypeScript interfaces.
It can be a useful retrieval layer for applications that need current web information but do not want to build and maintain their own crawler, index, ranking system, deduplication pipeline, and freshness controls. It does not, by itself, produce the finished answer a user sees in Perplexity’s consumer product.
That makes the product most relevant to AI application developers, RAG and agent builders, technical founders, and platform teams evaluating the cost and trade-offs of web search infrastructure.
The launch was covered by InfoWorld. Claims about index size, quality, freshness, and latency should be treated as Perplexity claims unless independently reproduced.
What Perplexity launched
Search API exposes a programmable version of Perplexity’s web-retrieval capability. The current documentation describes access to continuously refreshed, ranked web results with controls for how much content is returned and which sources are eligible.
Relevant capabilities include:
- Ranked web results with titles, URLs, snippets, and available source metadata.
- Content extraction so applications can use relevant page material without processing every full HTML document themselves.
- Domain allowlists and denylists.
- Country, regional, and language controls.
- Date and recency filtering.
- Multi-query requests containing up to five queries.
- Controls for maximum results, search context, per-page content, and total content volume.
- Official Python and TypeScript SDKs, as well as REST and cURL access.
- An interactive playground for trying queries before integrating the API.
The documented max_results range is 1 to 20, with a default of 10. The exact response fields and available controls can change, so production implementations should follow the current Search API documentation.
Why developers may want a retrieval API
A web-search product hides a large amount of infrastructure. A production search system needs to discover pages, crawl or retrieve them, maintain an index, remove duplicates, rank results, handle freshness, manage abuse, and cope with sources that are blocked, dynamic, paywalled, or frequently changing.
AI applications add another problem: raw HTML is usually too noisy and expensive to send directly to a language model. Developers need relevant results, source URLs, snippets, and enough extracted content to ground an answer without exceeding context or budget limits.
Search API lets a team outsource part of that problem while retaining control over what happens afterward. A typical application can:
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitches- Rewrite or decompose a user’s question.
- Send one or more targeted searches.
- Deduplicate and filter the returned sources.
- Fetch or extract additional page content where necessary.
- Rerank results for the application’s domain.
- Pass only relevant evidence to a language model.
- Validate citations and present the answer to the user.
Perplexity has described its system as ranking relevant document sub-units rather than requiring developers to work with entire pages. That positioning is useful for understanding the product, but it is not independent proof that Perplexity is better than every competing search index.
Search API versus Perplexity’s other developer products
| Product | Best for | Typical output |
|---|---|---|
| Search API | Custom RAG, agents, search products, and retrieval pipelines | Ranked web results and extracted content |
| Agent API | Managed web-grounded answers and tool-using workflows | Generated responses, citations, tools, and model orchestration |
| Sonar API | Perplexity-managed conversational answers | Generated web-grounded responses from Sonar models |
| Router API | Unified access to hosted open-weight models | Model responses |
| Embeddings API | Semantic search over private or collected documents | Vector embeddings |
Use Search API when your application needs the retrieval layer itself. Use Agent API or Sonar when you want Perplexity to manage more of the research and answer-generation process.
This is also a pricing distinction. Search API has a simple request price, while Agent and Sonar can involve model tokens, tool calls, and search-context charges. Perplexity’s product-selection guidance makes the same general separation: Search is for raw results and your own processing; Agent is for web-grounded generated answers.
What “real time” means—and does not mean
Perplexity describes Search API results as real-time and drawn from a continuously refreshed index. In practical terms, that means the service is designed to retrieve current web information rather than relying only on static model training data.
It does not mean every newly published page appears immediately, every source is indexed, or every returned result is current and correct. Freshness can vary by site and query. Pages behind logins, blocked from crawling, heavily dependent on JavaScript, restricted by publisher settings, or poorly discoverable may be absent or incomplete.
Rank #3
For breaking news, prices, regulations, financial information, and other time-sensitive subjects, applications should check publication dates, retrieve the underlying source where possible, and show users when information was last updated.
How to make a first request
Install an SDK
pip install perplexityainpm install @perplexity-ai/perplexity_aiThese commands are documented in Perplexity’s Search API quickstart.
Set your API key
export PERPLEXITY_API_KEY="your_api_key_here"On Windows PowerShell:
$env:PERPLEXITY_API_KEY="your_api_key_here"Create the key through the API Console’s API Keys page. The official SDKs can read the environment variable automatically.
Python
from perplexity import Perplexity
client = Perplexity()
search = client.search.create(
query="Perplexity Search API launch details",
max_results=5,
search_context_size="high",
)
for result in search.results:
print(result.title)
print(result.url)
print(result.snippet)cURL
curl -X POST 'https://api.perplexity.ai/search'
-H "Authorization: Bearer $PERPLEXITY_API_KEY"
-H "Content-Type: application/json"
-d '{
"query": "Perplexity Search API launch details",
"max_results": 5,
"search_context_size": "high"
}'A basic integration should preserve the URL, title, snippet, publication date when available, and any source metadata returned by the API. Treat retrieved text as untrusted input: web pages can contain irrelevant instructions, prompt-injection attempts, or misleading claims.
Pricing: $5 per 1,000 successful requests
According to Perplexity’s current pricing documentation, Search API costs $5 per 1,000 successful POST /search requests, equivalent to $0.005 per successful request. Search API has no additional token-based charge.
Important billing details:
- Successful requests are billed even when they return no results.
- Invalid, rate-limited, and upstream-failure requests are not billed.
- One request may contain up to five queries and still count as one billing unit.
- Model inference, embeddings, reranking, storage, page fetching, observability, and other infrastructure are separate costs.
| Successful requests per month | Approximate Search API cost |
|---|---|
| 1,000 | $5 |
| 10,000 | $50 |
| 100,000 | $500 |
| 1 million | $5,000 |
These figures describe Search API requests only. The relevant production metric is usually cost per completed answer or task, not cost per search. A system that performs query rewriting, multiple searches, page extraction, reranking, and model generation may cost considerably more than the headline search request.
Rate limits and the multi-query trap
The current documented Search API limit is 50 query units per second, with a burst capacity of 50 query units. A single-query request consumes one query unit. A request containing five queries consumes five query units.
Free tools Windows power users keep installed
One-click scans. No signup required.
That creates an important distinction:
- Five queries in one successful request can count as one billing unit.
- The same request still consumes five rate-limit units.
- Batching may reduce billing units but does not provide five times the throughput.
- Batching complicates per-query latency, result ownership, deduplication, and cost allocation.
For HTTP 429 responses, use capped exponential backoff with jitter. Do not retry malformed requests. Record retry counts and prevent a successful retry from triggering duplicate downstream processing. Perplexity documents its rate-limit behavior and retry guidance on its rate-limits page.
Where Search API fits in a real RAG or agent stack
User query
↓
Query rewriting or decomposition
↓
Perplexity Search API
↓
Filtering, deduplication, and reranking
↓
Page fetch or content extraction
↓
LLM generation
↓
Citation validation and responseSearch API should be treated as one component, not as a complete factuality system. A strong result can still lead to a poor answer if the snippet omits key context, the source is outdated, several sites repeat the same error, or the model misinterprets the evidence.
For production use, consider storing or logging:
- The query or a privacy-safe query hash.
- Provider status and latency.
- Returned domains and result count.
- Content volume and extraction settings.
- Cache hits, retries, and rate-limit events.
- Which sources were cited in the final answer.
- User corrections and answer-quality signals.
- Estimated cost per workflow.
Applications should also deduplicate by canonical URL and domain, apply trust rules, check dates, and keep source attribution attached to the evidence throughout the pipeline.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Evaluation matters more than the headline price
Perplexity announced searchevals, an open-source evaluation framework intended to help compare search APIs and retrieval quality. Company-reported quality and latency results should still be treated as claims unless independently reproduced.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
A practical proof of concept should use the application’s own representative queries and measure:
Best Value
- Precision of the top results.
- Recall of known relevant sources.
- Freshness for changing subjects.
- Long-tail and regional coverage.
- Duplicate-result rate.
- Latency distribution, including slow outliers.
- Error, timeout, and 429 rates.
- Citation correctness in the final generated answer.
- Total cost per completed answer.
Keep retrieval evaluation separate from end-to-end answer evaluation. A search provider can return relevant sources while the model still produces an incorrect or poorly cited answer.
Perplexity Search API versus Brave Search API
Brave Search API is a credible alternative when a team wants an independent search index rather than another AI-answer vendor. Brave lists Search API at $5 per 1,000 requests, advertises $5 in monthly credits, and states a capacity of 50 queries per second.
Brave emphasizes conventional web search and an independent index, while Perplexity emphasizes AI-oriented retrieval controls and integration with its answer and agent ecosystem. Both headline similar request pricing, so the decision should depend on actual relevance, freshness, regional coverage, latency, terms, and storage rights for the intended workload.
Brave also warns that its API does not automatically grant rights to third-party webpage content and that storage rights may depend on the selected plan. Developers evaluating any provider should separately review caching, retention, republishing, privacy, and model-training terms.
When not to use Perplexity Search API
Search API may be the wrong tool when the real problem is searching a private or controlled corpus. Sending internal-document queries to a public web-search service can add data-leakage, compliance, and relevance risks without solving the core indexing problem. A private vector database, enterprise search platform, or self-hosted crawler may be more appropriate.
Build or self-host when you need deterministic indexing, replayable results, specialized vertical ranking, strict data-retention control, a contractual SLA, or a workload large enough that per-request fees dominate. A public web index is also not a substitute for direct access to authoritative sources when completeness is essential.
Vendor dependency is another consideration. An application built around one provider’s result schema, ranking behavior, extraction format, and pricing can be difficult to migrate. Keep the retrieval interface in your own code, store normalized source metadata, and test at least one alternative if search is business-critical.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Bottom line
Perplexity Search API is a legitimate developer infrastructure product for applications that need fresh web retrieval without building a search engine from scratch. Its clearest use case is a custom RAG or agent pipeline where the application—not Perplexity—controls filtering, reranking, model selection, citation validation, and final answer generation.
At $5 per 1,000 successful requests, the entry price is easy to model, but it is not the total cost of an AI application. Test it against your own queries for relevance, freshness, latency, error rates, citation behavior, content rights, and cost per completed answer. Choose Agent API or Sonar when you want managed answer generation; choose an independent index such as Brave when that separation matters; and choose a private search stack when your corpus is internal or compliance-sensitive.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
