Perplexity API Pricing and 6 Alternatives Compared (2026)

Perplexity API pricing in 2026 is $2.50 per 1,000 web searches plus the model’s tokens on the Agent API, and $5.00 per 1,000 requests on the Search API. Fast Search lowers both search fees to $1.00 per 1,000, and the Search API has no token charges. Sonar Chat Completions support ended on 2026-09-27, so the Sonar token rates that many pricing pages still quote no longer describe what you pay. Every Perplexity price here comes from Perplexity’s pricing page and Agent API models page, read on 2026-10-25.

The six Perplexity API alternatives on this page are cloro, OpenAI’s web search tool, Gemini’s Grounding with Google Search, Claude’s web search tool, Exa’s Answer endpoint and Brave’s Answers plan. Five of them do what the Agent API does: a model searches the web and writes a cited answer for your product. The sixth, cloro, does a different job. It returns the answer that the perplexity.ai app shows a user, plus the answers of ChatGPT, Gemini, Copilot and Google AI Mode, so you can measure what those engines tell people.

The 6 best Perplexity API alternatives at a glance

The best Perplexity API alternative for the answer that Perplexity users actually see is cloro. To build your own cited answers, the closest swaps are OpenAI, Gemini and Claude, which each add web search to their own models, and Exa and Brave, which sell a complete answer per request.

Tool	What it returns	Search or request fee	Token charges	Free allowance
cloro	The perplexity.ai answer, with sources, plus other AI engines	$1.60 per 1,000 answers (Hobby), $1.22 at the top self-serve tier	None	500 credits a month
OpenAI web search	An answer from an OpenAI model, with url_citation annotations	$10 per 1,000 search calls	Model rates, including search content	None stated
Gemini grounding	An answer from Gemini, grounded in Google Search	$14 per 1,000 search queries (Gemini 3 and newer)	Model rates	5,000 search queries a month, paid tier
Claude web search	An answer from Claude, with cited text	$10 per 1,000 searches	Model rates; results count as input tokens	None stated
Exa Answer	An answer or JSON, with a list of citations	$5 per 1,000 requests	None listed	$10 credit a month, plus $10 at signup
Brave Answers	An answer from Brave, OpenAI-compatible	$4 per 1,000 searches	$5 per million input and output tokens	$5 credit a month
Perplexity Agent API (incumbent)	An answer from the model you choose	$2.50 per 1,000 searches, $1.00 with Fast Search	Model rates	None listed

The units are not the same. OpenAI, Gemini 3, Claude and Brave bill each search the model runs, and one answer can run several. Exa and cloro bill each answer. So compare the cost of one answer, as in the next table, and not only the fees.

The cost of one answer, on the same assumptions

This table uses our own arithmetic: one search, 3,000 input tokens and 500 output tokens, on the cheapest listed model that supports web search. Your prompts will differ, but the order is clear.

Vendor	Model	Cost of one answer	Per 1,000 answers
Perplexity Agent API, Fast Search	openai/gpt-6-luna	$0.00155	$1.55
cloro (Hobby, async)	Perplexity’s own	$0.0016	$1.60
Exa Answer	Exa’s default	$0.005	$5.00
OpenAI web search	gpt-6-luna	$0.01055	$10.55
Gemini grounding (after the free 5,000)	gemini-3.5-flash-lite	$0.01615	$16.15
Brave Answers	Brave’s own	$0.0215	$21.50
Claude web search	Not checked	$0.01 plus tokens	$10 plus tokens

How we got them: Perplexity is $0.10 and $0.50 per million tokens plus $0.001 a search. OpenAI is the same token rates plus $0.01 a search call. Gemini 3.5 Flash-Lite is $0.30 and $2.50 per million tokens plus $0.014 a search query. Brave is $5 per million tokens plus $0.004 a search. Exa and cloro have one price for each answer. We did not confirm which Claude model is the cheapest with web search, so that row has the search fee only.

Perplexity API pricing: how much it costs per token and per search

Perplexity sells five APIs, and each one bills differently. Two of them return web data: the Agent API, which writes an answer, and the Search API, which returns ranked results.

API	What it returns	How it bills	Rate
Agent API	An answer from the model you choose, with search results	Model tokens plus tool fees	Model rates, plus $2.50 per 1,000 web searches
Search API	Ranked web results, with no answer	Per successful request	$5.00 per 1,000, or $1.00 with Fast Search
Orchestrator API	Model calls through one endpoint (private preview)	Model tokens, no request fees	Per model
Embeddings API	Text embeddings	Per token	$0.004 to $0.05 per million tokens
Decisions API	Yes, no and scored answers with probabilities	Input tokens only	$0.01 to $0.02 per million input tokens

The Search API bills each successful POST /search request, and one request can carry up to five queries. Invalid, rate-limited and failed requests are free, but a successful request with no results is billed.

Agent API tool fees: $1.00 to $5.00 per 1,000 calls

The Agent API adds a fee each time the model calls a tool. Token costs are separate.

Tool	Price per call	Per 1,000 calls
web_search (standard)	$0.0025	$2.50
web_search (Fast Search)	$0.001	$1.00
image_search	$0.0025 (successful calls)	$2.50
fetch_url	$0.0005	$0.50
people_search	$0.005	$5.00
finance_search	$0.005	$5.00
sandbox	$0.03 per session of up to 20 minutes	$30.00 per 1,000 sessions

All five effort levels set web_search to Fast Search by default, so a search on an effort level costs $1.00 per 1,000 unless you change search_type.

Cost per request by effort level: $0.0014 to $0.78

An effort level is a configuration that Perplexity manages: a model, a system prompt, a step limit and a set of tools. Perplexity measured the average cost of a request on two benchmarks, BrowseComp (hard questions that need many searches) and DeepSearchQA. The per-1,000 figures are those averages times 1,000.

Effort level	Model (2026-10-25)	Max steps	Cost per request, BrowseComp	Cost per request, DeepSearchQA	Per 1,000 requests
fast	openai/gpt-6-luna	1	$0.0014	$0.0018	$1.40 to $1.80
low	openai/gpt-6-luna	5	$0.0060	$0.0120	$6 to $12
medium	openai/gpt-6-luna	15	$0.0160	$0.0310	$16 to $31
high	openai/gpt-6-sol	15	$0.1360	$0.1210	$121 to $136
xhigh	anthropic/claude-opus-5-5	100	$0.7800	$0.2180	$218 to $780

Sources: Agent API vs Sonar benchmarks and effort levels, read on 2026-10-25.

What the table says:

• The effort level moves the bill more than anything else. A medium request costs about 11 to 17 times a fast one, and xhigh costs up to 557 times as much.
• Perplexity can change the model behind a dynamic effort level. Its docs say that updates “target the same cost band”, and you can pin a version, such as [email protected], to keep one configuration.
• The fast level runs on the priority service tier. On a model that supports it, that tier bills tokens at 2 times the listed rate.
• Your own prompts will cost more or less than these averages. Each response reports its cost in usage.cost.total_cost, so you can measure your own.

Model token rates: Sonar is now $0.25 and $2.50 per million tokens

On the Agent API you can also choose a model directly. These are the models that the effort levels use, plus Perplexity’s own sonar. Rates are per million tokens, for inputs up to the context limit in brackets.

Model	Input	Output	Cache read
perplexity/sonar	$0.25	$2.50	$0.0625
openai/gpt-6-luna (up to 272k)	$0.10	$0.50	90% off input
openai/gpt-6-sol (up to 272k)	$2.00	$10.00	90% off input
anthropic/claude-opus-5-5	$4.00	$20.00	$0.20

The models page lists 28 models from OpenAI, Anthropic, Google, xAI, Z.AI, Moonshot AI and NVIDIA. The flex service tier halves token rates and priority doubles them, on models that list those tiers.

What happened to Sonar pricing

Perplexity’s docs say that “Sonar Chat Completions support ended on September 27, 2026.” Synchronous and streaming Sonar requests keep working, because Perplexity now runs them as Agent API requests, rolled out model by model. Asynchronous Sonar requests no longer work, and Perplexity points them to background mode.

Perplexity also maps each Sonar model to an effort level: Sonar and Sonar Pro to fast, Sonar Reasoning Pro to low, and Sonar Deep Research to high. On its benchmarks, Sonar cost $0.0059 to $0.0070 a request and Sonar Deep Research $0.57 to $0.61. So a team that moved from Sonar to fast pays less per request, by Perplexity’s own figures.

Rate limits follow what you have spent

Perplexity sets Agent API rate limits by usage tier, and the tier depends on your total credit purchases. A tier never goes down.

Tier	Total credits bought	Agent API requests a second
Tier 0	$0	1
Tier 1	$50	3
Tier 2	$250	8
Tier 3	$500	17
Tier 4	$1,000	33
Tier 5	$5,000	33

The Search API has its own limit for every account: 50 queries a second, with a burst of 50. Source: rate limits and usage tiers, read on 2026-10-25.

The Perplexity API vs the perplexity.ai answer: what each one returns

The Agent API and the perplexity.ai app both write a cited answer from a web search. They are not the same answer. The API answer comes from the configuration you send, or from an effort level that Perplexity publishes. The app answer is the one that Perplexity’s product gives each user.

This difference decides which one you need:

• You are building a product that answers questions from the web. The API is the right tool. You choose the model, the tools and the cost, and you own the prompt.
• You are measuring Perplexity, for example how it describes your brand or which sources it cites in your category. Then the API is the wrong tool, because nobody reads its answer. You need the answer that the app shows.

The table compares the fields that each one returns. The Agent API column comes from Perplexity’s web search docs, and the cloro column from cloro’s Perplexity endpoint docs.

	Perplexity Agent API	cloro Perplexity endpoint
Request	input, plus effort or a model, tools, instructions	prompt, country, and state where supported
Who writes the answer	The model you choose, or the effort level’s model	Perplexity’s app, as a logged-out user in that country sees it
System prompt	Yours, or the effort level’s published prompt	Perplexity’s own
Answer text	output_text in a message item	result.text, and result.markdown on request
Sources	search_results item: id, url, title, snippet, date, last_updated, source	result.sources: position, url, label, description
Inline citations	Only if your prompt asks for them, per Perplexity’s docs	result.citationPills, one entry for each cited source
Search queries the engine ran	queries in the search_results item	result.search_model_queries
Shopping, hotels, places, videos, images	Not returned	result.shopping_cards, result.hotels, result.places, result.videos, result.images, when the app shows them
Follow-up questions	Not returned	result.related_queries
Cost in the response	usage.cost.total_cost	X-Credits-Charged header (sync) or creditsCharged (async)

Three rows explain most of the gap:

1. The model. In October 2026 the fast, low and medium effort levels run openai/gpt-6-luna, high runs openai/gpt-6-sol and xhigh runs anthropic/claude-opus-5-5. Perplexity’s docs say that the models behind an effort level can change. An API answer is therefore an answer from that model, with Perplexity’s search attached.
2. The citations. Perplexity’s web search docs say that “whether the model adds markers to the answer is prompt-dependent”. The app shows its citations on every answer, and cloro returns them as citationPills.
3. The blocks around the text. When the app detects shopping, travel or location intent, it adds product cards, hotels or places. The Agent API response has no fields for them. cloro parses them. Shopping cards are rare on Perplexity: cloro’s docs count fewer than 1 in 1,000 answers as of May 2026.

We did not measure how often the API and the app cite the same sources. The comparison above comes from the two sets of docs. In our 500-query study, the Search API returned a generated answer on 0 of 500 queries. That result is by design, and it shows that each Perplexity product returns a different layer of data.

The 6 Perplexity API alternatives, compared

The best Perplexity API alternatives are cloro for the answer Perplexity users see, OpenAI for web search on OpenAI models, Gemini for answers grounded in Google Search, Claude for answers with quoted source text, Exa for a flat $5 per answer and structured output, and Brave for an answer from an independent index.

01

1. cloro: best for the answer that perplexity.ai shows its users

cloro’s Perplexity endpoint answers a different question from the Agent API. The Agent API lets your product write an answer with Perplexity’s search. cloro sends your prompt to perplexity.ai, in the country you choose, and returns the answer that a logged-out user there sees. The response carries result.text, result.sources, result.citationPills, the search queries Perplexity ran (result.search_model_queries), and the shopping, travel and place blocks when the app shows them.

This is the data for AI visibility work: which sources Perplexity cites in your category, and what it says about your brand. The same key returns ChatGPT, Gemini, Copilot, Google AI Mode and the Google AI Overview, so one integration covers the engines your users ask. For the citation fields, see the Perplexity citations API.

cloro also has a hosted MCP server at https://mcp.cloro.dev/mcp (setup), Python and TypeScript SDKs, and an async route with webhooks for batches.

Pricing: A Perplexity answer is 4 credits on the async route (POST /v1/async/task), and a synchronous /v1/monitor/perplexity call adds 2. State targeting adds 2. Lite is $30/month for 37,500 credits ($0.80 per 1,000 credits), so $3.20 per 1,000 answers. Hobby is $100 for 250,000 credits, so $1.60 per 1,000 answers. The largest self-serve plan, Enterprise 5,000, is $0.305 per 1,000 credits, so $1.22 per 1,000 answers. The Free plan has 500 credits a month. See the pricing page.

Pros

• +Returns the perplexity.ai answer as JSON, with sources and citation pills.
• +Shopping cards, hotels, places, videos and related questions, when Perplexity shows them.
• +ChatGPT, Gemini, Copilot, Google AI Mode and Google Search under the same key.
• +$1.60 per 1,000 Perplexity answers on Hobby, with no token charges.

Cons

• −No choice of model, system prompt or tools: you get Perplexity's answer.
• −No raw search endpoint for Perplexity's index.
• −Perplexity can classify a prompt as a personal search and return an error, per cloro's docs.

02

2. OpenAI web search: best for web search on OpenAI models

OpenAI’s web search tool adds search to a Responses API call. The response has a web_search_call item, then a message item whose text carries url_citation annotations with url, title, start_index and end_index. The full list of pages that the model read comes back only if you send include: ["web_search_call.action.sources"]. OpenAI’s guide says that “the number of sources is often greater than the number of citations”.

The Agent API can already run OpenAI models. Its fast, low and medium effort levels use openai/gpt-6-luna. So the reason to go direct is the OpenAI platform itself. On search fees, Perplexity is cheaper: $1.00 to $2.50 per 1,000 searches, against $10.

Pricing: Web search $10.00 per 1,000 calls, plus “search content tokens billed at model rates”; gpt-6-luna at $0.10 input and $0.50 output per million tokens. The preview tool for non-reasoning models is $25.00 per 1,000 calls, with free search content tokens (OpenAI pricing).

Pros

• +One web_search tool on the Responses API, on models such as gpt-6-luna.
• +Inline url_citation annotations with start and end offsets.
• +gpt-6-luna supports it at $0.10 and $0.50 per million tokens.

Cons

• −$10 per 1,000 search calls, 4 times Perplexity's standard search fee.
• −One answer can run several billed searches.
• −The full list of sources comes back only on request.

03

3. Gemini grounding: best for answers grounded in Google Search

Grounding with Google Search lets a Gemini model search Google before it answers. The grounding guide, updated 2026-10-13, documents the Interactions API: the response is a steps array with google_search_call, google_search_result and model_output, and the citations are url_citation annotations. The older generateContent API still returns groundingMetadata, with groundingChunks, groundingSupports and webSearchQueries.

Billing changed with Gemini 3. Google’s docs say that “your project is billed for each search query that the model decides to execute”, at $14 per 1,000 after 5,000 free queries a month. Gemini 2.5 models still bill each grounded prompt, at $35 per 1,000 after 1,500 free prompts a day.

Pricing: Gemini 3 and newer: 5,000 free search queries a month on the paid tier, then $14 per 1,000; gemini-3.5-flash-lite tokens at $0.30 input and $2.50 output per million. Gemini 2.5: $35 per 1,000 grounded prompts after 1,500 a day (Gemini pricing).

Pros

• +Grounds the answer in Google Search results.
• +5,000 free search queries a month on Gemini 3 and newer.
• +url_citation annotations on the Interactions API.

Cons

• −$14 per 1,000 search queries after the free 5,000.
• −Each query the model runs is billed, and one prompt can run several.
• −Not on the free tier for Gemini 3 models, except for tests in AI Studio.

04

4. Claude web search: best for answers that quote their sources

Claude’s web search tool runs on the Messages API. The response has a server_tool_use block, a web_search_tool_result block with web_search_result items (url, title, page_age, and encrypted_content), and text blocks with citations of type web_search_result_location. Each citation carries cited_text, up to 150 characters, and Anthropic’s docs say that “citations are always enabled for web search”.

The cost grows with the conversation. Anthropic’s docs say that search results “are counted as input tokens, in search iterations run during a single turn and in subsequent conversation turns”, and that simple questions use 1 to 3 searches while research questions can use 10 or more. Set max_uses to cap them.

Pricing: $10 per 1,000 searches, “plus standard token costs for search-generated content”; each search counts once, whatever the number of results (Claude web search docs).

Pros

• +Citations are always on, with up to 150 characters of cited text.
• +Failed searches are not billed.
• +Batch requests cost the same as live requests.

Cons

• −$10 per 1,000 searches, plus tokens.
• −Search results count as input tokens, in later turns too.
• −The page content comes back encrypted.

05

5. Exa Answer: best for a flat price per answer and structured output

Exa’s Answer endpoint runs an Exa search and has an LLM write either a direct answer or a summary with citations. The response has answer (a string, or a JSON object when you set outputSchema), citations with title, url, publishedDate and author, and costDollars, so every response states its own cost.

Exa is the only vendor here, other than cloro, that bills each answer at one flat rate. That makes the cost easy to predict. The trade is the index: in our 500-query test, only 32.3% of Exa’s top-10 URLs also ranked in Google’s top 10. Our Exa pricing and alternatives page covers Exa in more depth.

Pricing: Answer $5 per 1,000 requests, with up to 10 results; $10 of free credit every month plus a $10 onboarding bonus, with no payment method (Exa pricing).

Pros

• +$5 per 1,000 requests, with no token line.
• +Returns JSON when you send an outputSchema.
• +OpenAI-compatible chat completions interface.

Cons

• −Citations are one list for the whole answer, with no inline spans.
• −One price on the pricing page, although the endpoint has four models.
• −Answers come from Exa's index, which ranks far from Google.

06

6. Brave Answers: best for an answer from an independent index

Brave’s Answers plan returns a completed answer through an OpenAI-compatible endpoint, https://api.search.brave.com/res/v1/chat/completions. Citations arrive as tagged objects in the stream, with start_index, end_index, url and snippet, and Brave’s docs say that citations and research mode “require streaming mode to be true”.

The plan card says $4 per 1,000 requests, but Brave’s docs bill each search: “cost = (searches × $4/1000) + (input_tokens × $5/1000000) + (output_tokens × $5/1000000)”. Brave’s worked example, 2 searches with 1,234 input and 300 output tokens, costs $0.01567. Our Brave Search API alternatives page covers its Search plan.

Pricing: Answers $4 per 1,000 searches plus $5 per million input and output tokens, 2 requests a second, $5 of free credit every month (Brave pricing).

Pros

• +Answers from Brave's own independent index.
• +OpenAI SDK compatible, with model set to brave.
• +$5 of free credit every month.

Cons

• −Tokens cost $5 per million, about half of the bill in Brave's own example.
• −Citations arrive only when you stream.
• −2 requests a second by default.

Which Perplexity API alternative to pick

Background

What Perplexity sells to developers today

+

Perplexity’s developer platform has five APIs. The Agent API is the main one. It calls models from OpenAI, Anthropic, Google, xAI, Z.AI, Moonshot AI, NVIDIA and Perplexity, and it has built-in tools: web search, URL fetch, image search, people search, finance search, a code sandbox and MCP. Perplexity says the Agent API is compatible with the Open Responses standard. The Search API returns ranked, dated results from Perplexity’s own index. The Orchestrator API, in private preview, routes model calls through Chat Completions and Messages endpoints. Embeddings and Decisions complete the list.

You can buy credits in the API console or through AWS Marketplace, and the Agent API takes user_location with a country, region, city, latitude and longitude.

How we compared, and what these numbers rest on

+

The prices are the vendors’ own. Each rate comes from the vendor’s pricing page or docs, linked inline and read on 2026-10-25. We quote the real-time rate. Prices change, so check the linked page before you commit.

The cost per request is Perplexity’s measurement. The effort-level costs come from Perplexity’s benchmark page. We did not run those benchmarks, and your prompts will cost more or less.

We did not test the API against the app. The comparison of fields comes from Perplexity’s docs and from cloro’s docs. The 500-query figures come from our own Perplexity Search API study.

We make one of the products on this page. Ours is listed first because this is our site. The vendor links go to primary sources, so you can check our framing against them.

The bottom line

Perplexity API pricing in 2026 is model tokens plus $2.50 per 1,000 web searches on the Agent API, or $1.00 with Fast Search, and $5.00 per 1,000 requests on the Search API. Sonar’s token rates no longer apply, and the effort level you choose moves the bill from about $1.40 to $780 per 1,000 requests. For your own cited answers, the Agent API’s fast level is the cheapest option here, and Exa is the simplest at a flat $5 per 1,000. OpenAI, Gemini, Claude and Brave cost about $10 to $22 per 1,000 answers on our assumptions. If you need the answer that Perplexity shows its users, the API cannot give it to you. cloro returns it for $1.60 per 1,000 on Hobby, with 500 free credits a month to test your own prompts.