Perplexity API

Perplexity's Sonar models integrate web search directly into the inference pipeline, automatically retrieving and ranking current web data during response generation. The API supports four model variants (Sonar, Sonar Pro, Sonar Reasoning Pro, Sonar Deep Research) with configurable search context depth (Low/Medium/High), enabling responses grounded in real-time information without requiring separate search orchestration. Search context size directly affects both latency and pricing, allowing builders to trade off comprehensiveness against cost.

The Agent API provides unified access to third-party LLM models (OpenAI, Anthropic, Google, xAI) through Perplexity's infrastructure, with two built-in web search tools (web_search and fetch_url) available as function calls. Builders invoke third-party models via a single API endpoint, and the models can autonomously call web_search ($0.005/invocation) or fetch_url ($0.0005/invocation) to retrieve current information. Pricing is transparent: model tokens charged at direct provider rates with no markup, plus separate tool invocation fees.

Perplexity API uses API key-based authentication where developers create and manage keys through the API Key Management dashboard. Keys are used in HTTP requests to authenticate API calls. The authentication mechanism is standard HTTP header-based (typical pattern: Authorization: Bearer <api_key>), enabling integration with standard HTTP clients and SDKs. Key management dashboard provides visibility into key creation, rotation, and usage.

Perplexity provides an official SDK (language support not specified in documentation) with quickstart guides and integration documentation. The SDK abstracts HTTP request/response handling and provides language-native interfaces for API calls. SDK documentation includes guides for common use cases (e.g., building search assistants, implementing RAG pipelines), enabling developers to get started quickly without building HTTP clients from scratch.

The Search API provides direct access to Perplexity's web search infrastructure, returning ranked search results with advanced filtering capabilities. Unlike the Sonar or Agent APIs which generate text responses, the Search API returns raw search results suitable for building custom search UIs, RAG pipelines, or search-augmented applications. Pricing is flat-rate ($5 per 1,000 requests) with no token-based costs, making it cost-predictable for high-volume search workloads.

The Embeddings API generates vector embeddings for text, supporting both standard and contextualized embedding variants. Embeddings can be used for semantic search, similarity matching, and RAG (Retrieval-Augmented Generation) pipelines. The API supports two embedding strategies: standard embeddings for general-purpose similarity, and contextualized embeddings that incorporate surrounding context for improved relevance in domain-specific applications.

Within the Agent API, third-party LLM models can autonomously invoke two web search tools (web_search and fetch_url) via function calling. The model decides when to search based on query content, and Perplexity's infrastructure executes the search and returns results to the model for incorporation into its response. This enables agentic workflows where the model acts as a decision-maker: it can choose to use training data, invoke web_search to retrieve current information, or fetch_url to extract content from specific URLs. Each tool invocation is charged separately ($0.005 for web_search, $0.0005 for fetch_url).

The Sonar API supports three configurable search context depths (Low, Medium, High) that control how comprehensively the model searches the web during inference. Low context (default) performs minimal search for speed and cost; Medium context balances comprehensiveness and cost; High context performs exhaustive search for research-grade responses. Search context depth directly affects both response latency and pricing, with High context costing 2-3x more than Low context per request. This enables builders to implement dynamic pricing and latency strategies based on query complexity or user tier.

The Sonar Deep Research model variant includes native citation token generation, automatically extracting and attributing sources from web search results in the model response. Citations are generated as structured tokens (priced at $2/1M tokens) separate from output tokens, enabling builders to extract source attribution without post-processing. This is particularly useful for research applications, fact-checking tools, and content creation where source credibility is critical. Citations include source URLs and context snippets, enabling users to verify claims against original sources.

The Sonar Reasoning Pro and Sonar Deep Research models support reasoning tokens, which represent the model's internal reasoning process during inference. Reasoning tokens are generated during problem-solving and are priced separately ($3/1M for Sonar Deep Research, pricing for Sonar Reasoning Pro not documented). This enables builders to observe and optimize the model's reasoning steps, and to implement reasoning-aware pricing where complex problems that require more reasoning steps cost more. Reasoning tokens are particularly useful for research, mathematical problem-solving, and multi-step decision-making tasks.

The Agent API includes a fetch_url tool ($0.0005 per invocation) that enables LLM models to retrieve and extract content from specific URLs identified during reasoning or search. When a model invokes fetch_url, Perplexity's infrastructure fetches the page, extracts relevant content (text, structured data, metadata), and returns it to the model for incorporation into the response. This enables agentic workflows where the model can autonomously gather information from specific sources without requiring the application to manage HTTP requests or content extraction.

The Agent API implements transparent pricing where third-party LLM models (OpenAI, Anthropic, Google, xAI) are charged at direct provider rates with no Perplexity markup. Model token costs are separated from tool invocation costs (web_search $0.005, fetch_url $0.0005), enabling precise cost attribution. Builders can see exactly how much they're paying for model inference vs tool invocations, and can optimize costs by choosing cheaper models or reducing tool invocations. This contrasts with opaque pricing models where tool costs are bundled into token counts.