Table of Contents
Perplexity has launched the Orchestrator API, giving developers access to frontier and open-weight AI models through one API key, consolidated billing, and automatic failover between deployments of the same model.
The service covers models from OpenAI, Anthropic, Google, and xAI, alongside open-weight families including GLM, Kimi, and DeepSeek. Developers can choose a model for each workload or preview an optional routing system that selects one based on plain-language instructions about the task.
Teams building applications around several labs' models get both model access and the infrastructure needed to keep requests running when a provider becomes slow or unavailable. They can also change their model mix without maintaining a separate billing relationship for every supported provider.
Connecting Existing Applications
Orchestrator supports OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages request formats. Every model in the catalog accepts all three formats, although individual capabilities still depend on the model being called. Open-weight models are served by Perplexity or its inference partners.
The quickstart shows how to use existing OpenAI or Anthropic software development kits with a Perplexity API key and a catalog model ID. OpenAI SDK users point their client at the Orchestrator endpoint. Anthropic SDK users use the same address without the trailing /v1, because that SDK adds /v1/messages itself.
The API is stateless, so applications send the conversation history with each request rather than relying on a conversation stored by the service. Integrations that rely on server-side state in another provider's API therefore need adjusting when they move over.
Perplexity says its underlying production model layer routes hundreds of millions of requests across more than 85 models and more than a dozen providers. Orchestrator opens access to that shared infrastructure, with the public catalog defining which models developers can call.
Two Layers of Routing
Orchestrator separates choosing a model from choosing where that model runs. Its provider-routing system automatically selects a deployment using observed error rates, available capacity, and latency. When a deployment returns a provider error, rate limit, or timeout, the platform retries on another deployment of the same model when one is available.
That failover does not substitute a different model. A developer requesting a particular model continues to request that model while Perplexity handles the serving infrastructure behind it. Invalid requests and prompts that exceed the model's context window return an error without being retried elsewhere.
If every deployment fails, the API returns HTTP 429 with a Retry-After header. Requests that fail before producing output are not billed. For streaming requests, failures after generation begins appear as an error within the stream, and delivered tokens are billed.
Optional model routing, available in preview, operates one level above that process. Setting model to perplexity/auto lets a decision model examine the conversation and choose among developer-defined routes. Each routing configuration contains a default model and one to five routes, pairing a model with a description of the work it should handle.
The decision model reads those descriptions and the conversation text, not the route names or model IDs. A team could describe a route for debugging crashes and assign it a stronger coding model, while leaving routine requests with a lower-cost default. If no route fits, the default handles the request.
Without a custom configuration, the current default policy uses openai/gpt-6.1-sol, with a simple-task route to openai/gpt-6-luna for greetings, quick facts, titles, labels, and short rewrites or translations. The response identifies the model that actually served the request.
Routing happens independently on each turn, so one conversation can move between models. Each model maintains its own prompt cache, which stores reusable input to reduce repeated processing. Conversations containing images, audio, video, or files always go to the default model rather than through the text-based routing decision, so the default model's media support shapes how teams set up routing.
Also in preview, Auto effort selects how much reasoning a supported model uses on its next turn under a developer-defined policy. For example, an agent could use more reasoning when recovering from a tool error without switching to another model.
Token Pricing and Access Tiers
Orchestrator uses per-token pricing, with no per-request fee or additional platform fee on top of credits. Billing follows the served model's published rates regardless of which deployment handles the request. With automatic model routing, the selected model determines the rate.
Input, output, and cached input have separate rates, and reasoning tokens are billed at the output rate. Some models also charge for writing inputs to a cache, so the cost of a workflow depends on both model selection and how the application reuses its conversation history.
The API Console breaks spending down by model, project, API key, and date. Administrative controls include model allowlists, user restrictions, and spending caps, so teams can constrain which models an application uses and manage costs centrally.
Google, xAI, and open-weight models are available at every usage tier. OpenAI and Anthropic models generally require Tier 1 or higher, while Claude Opus 5, Opus 5.5, and the Fable models require Tier 2 or higher. Developers can check the model catalog for individual access requirements, context limits, and token rates before defining their routes.