Try it
Run a live Perplexity rank check
One real call, no signup and no key. The cited sources and the raw JSON arrive together.
Endpoints & Pricing
Perplexity Citations, One Price Per Call
One call is one Perplexity-labeled answer and the sources cited in it. The charge is a single flat number you know before you send it.
Single engine
- Up to 10 cited sources, 15 with
prompt_type=deep - Position, URL, domain, title and cited text per source
- Domain tracking with exact and subdomain matches
- The whole answer in
response_text
All four engines
- Perplexity, ChatGPT, Claude and Gemini in one call
- Half the price of four separate single-engine calls
- One blended visibility score across the four
- $10.00 an engine at Default, $0.50 an engine at Scale
Growth needs a one-time $100 deposit and Scale a one-time $500 deposit. Both are permanent, neither recurs, and a tier once earned never downgrades. Every account starts with free API calls.
Quick Start
A Perplexity Rank Check You Can Price in Advance
Three query parameters and one header. The cost of a call is the same whether the answer runs to two paragraphs or ten.
# The Perplexity answer for a keyword, with every source it cited curl "https://apiserpent.com/api/ai/rank/perplexity?q=best+password+manager" \ -H "X-API-Key: YOUR_API_KEY" # Track a domain: position, match type and the score come back filled in curl -G "https://apiserpent.com/api/ai/rank/perplexity" \ --data-urlencode "q=best password manager" \ -d "domain=1password.com" -d "prompt_type=brand" \ -H "X-API-Key: YOUR_API_KEY"
# pip install requests import requests resp = requests.get( "https://apiserpent.com/api/ai/rank/perplexity", params={"q": "best password manager", "domain": "1password.com"}, headers={"X-API-Key": "YOUR_API_KEY"}, timeout=60, ) row = resp.json()["results"]["perplexity"] print(row["target_position"], "of", row["total_citations"]) for c in row["citations"]: print(c["position"], c["domain"], c["cited_text"][:80])
// Node 18+ — fetch is built in. Allow a generous timeout. const qs = new URLSearchParams({ q: 'best password manager', domain: '1password.com' }); const res = await fetch('https://apiserpent.com/api/ai/rank/perplexity?' + qs, { headers: { 'X-API-Key': process.env.SERPENT_KEY }, signal: AbortSignal.timeout(60000) }); const { results, aggregate } = await res.json(); console.log(results.perplexity.target_position, aggregate.visibility_score); console.log(aggregate.all_domains_cited.join(', '));
{
"success": true,
"run_id": "b48e21f7-6c05-4a3d-8f11-90d7c2ea5533",
"keyword": "best password manager",
"target_domain": "1password.com",
"results": {
"perplexity": {
"llm": "perplexity",
"model": "sonar-pro",
"citations": [
{
"position": 1,
"url": "https://1password.com/pricing",
"title": "1Password Pricing",
"cited_text": "...family plans cover five people on one subscription [1]",
"url_normalized": "1password.com/pricing",
"domain": "1password.com"
},
{
"position": 2,
"url": "https://example.com/password-managers-tested",
"title": "We Tested 9 Password Managers",
"cited_text": "...autofill reliability is where most of them differ [2]",
"url_normalized": "example.com/password-managers-tested",
"domain": "example.com"
}
],
"target_found": true,
"target_position": 1,
"target_match_type": "exact",
"target_matched_domain": "1password.com",
"total_citations": 12,
"response_text": "For most people the choice comes down to autofill and sharing...",
"error": null
}
},
"aggregate": {
"visibility_score": 25,
"found_in": ["perplexity"],
"best_position": { "engine": "perplexity", "position": 1 },
"all_domains_cited": ["1password.com", "example.com"],
"total_latency_ms": 13350
},
"meta": { "elapsed": "13380ms", "timestamp": "2026-09-08T10:00:00.000Z" }
}
A first-place citation scores 25 here, not 100, because visibility_score is weighted per engine and blended across the engines in the response — a Perplexity-only call tops out at 25. Chart target_position for a single engine, and call /api/ai/rank for the full 0–100 blend across all four.
Data Fields
Every Field a Perplexity Call Returns
Named JSON fields you can index into directly. Every key is present on every response, even when the answer cited nothing at all.
Cited source fields
- citations[].position
- citations[].url
- citations[].title
- citations[].cited_text
- citations[].url_normalized
- citations[].domain
- total_citations
Domain tracking fields
- target_domain
- target_found
- target_position
- target_match_type
- target_matched_domain
- aggregate.found_in
- aggregate.best_position
Answer and run fields
- run_id
- keyword
- llm
- model
- response_text
- aggregate.visibility_score
- aggregate.all_domains_cited
- aggregate.total_latency_ms
- meta.elapsed
Request parameters
- q (the question, required)
- keyword (alias for q)
- domain (optional target)
- prompt_type=standard (default)
- prompt_type=deep (up to 15 citations)
- prompt_type=brand (comparison form)
- X-API-Key (request header)
Why Perplexity citations
What Perplexity citation data is, and why the price matters
An answer names its sources, and the ordering is meaningful. What is unusual here is being able to price a call before you make it.
One number per call, known before you call
Perplexity’s own API bills twice: a per-request fee that changes with the amount of context, plus per-token charges in both directions. A caller therefore cannot work out what an answer will cost until after it has been produced.
This endpoint charges one flat rate per call at your tier. A budget for 50,000 checks is a multiplication, not an estimate.
The cheap rate elsewhere does not exist here
DataForSEO’s LLM Scraper sells an AI answer for $1.20 per 1,000 in its standard queue, read from their own pricing page on 2026-09-10. It is the rate most readers arrive quoting, and it has no Perplexity equivalent: that page states it covers only ChatGPT and Gemini.
So the number a reader might arrive expecting to beat is simply not on offer for this engine. What is left are rates behind a monthly plan or a custom quote.
Watch out for the $5.00 lookalike
Perplexity publishes a Search API at $5.00 per 1,000 requests, which reads like a per-answer price and is not one. It returns web results rather than a Perplexity answer, so there is no answer text and nothing to be cited in.
Naming it here so the number does not come as a surprise later. It is a different product, priced for a different job.
Ordered by first mention, not by array index
citations[] is ordered by first appearance in the answer, which makes position a real ordering rather than an array index, and target_position the number worth charting week over week.
The per-engine ceiling applies to the score: a Perplexity-only call tops out at 25. Use /api/ai/rank for the full 0–100 blend across the four engines.
Price comparison
What One Perplexity Answer Costs, By Vendor
Each cell is that vendor’s lowest published rate. Three of the rows are Perplexity’s own products, priced on a different basis from everything else here.
| Provider | Cost per 1,000 | Unit | What the lowest rate requires | Free tier |
|---|---|---|---|---|
| Serpent (ours) | $1.00 | 1 call = 1 Perplexity answer | One-time $500 deposit, permanent | Free to start |
| Oxylabs | $0.95 | Per result, 24 data points | A custom quote. Its cheapest rate on a plan with a published price is $1.00 on $999 a month | 2,000 results |
| SearchApi.io | $1.00 | Per search | $5,000 a month | 100 requests |
| cloro.dev | $1.22 | 4 credits per request | $5,000 a month | 500 credits a month |
| Bright Data | $1.30 | Per record | $499 a month | 5,000 records a month |
| Perplexity Sonar (own API) | $5.00 to $12.00 plus tokens | Per request, priced by context size | $1 per million tokens in each direction on top | None |
| Perplexity Sonar Pro (own API) | $6.00 to $14.00 plus tokens | Per request, priced by context size | $3 and $15 per million tokens on top | None |
| Perplexity Search API | $5.00 | Per request | Returns web results, not a Perplexity answer | None |
| DataForSEO LLM Scraper | — | — | Does not cover Perplexity at all | — |
The Oxylabs, DataForSEO and SearchApi.io rows were re-read from those pages on 2026-09-10; the rest were read on 2026-09-08 and are unchanged. Oxylabs also advertises a cheaper non-JavaScript band without saying whether it reaches the AI targets, so its lowest published JavaScript rate is the one shown. Its plan tiles rotate in a carousel, so a single page view shows only part of the ladder.
$1.00 per 1,000 on Scale is the lowest rate on this table that a one-time payment reaches. SearchApi.io matches it and needs $5,000 a month; Oxylabs goes lower, to $0.95, but only on a quote-only tier, and its cheapest rate on a plan with a published price is $1.00 on $999 a month. The rest sit behind monthly plans of $499 to $5,000. Ours is unlocked by depositing $500 once, and that tier is never withdrawn.
At Default and Growth we are not the cheapest per call, and the honest way to say why is that the usual cheap option is missing. DataForSEO’s $1.20 per 1,000 — the rate most comparisons of this market quote — does not cover Perplexity, so it is not an alternative on this page even though it is on the ChatGPT one.
Perplexity’s own API is the closest first-party option, and it bills on two axes at once: a per-request fee that moves with context size, plus per-token charges in both directions. That is a reasonable design and a hard one to budget against, because the cost of an answer is only knowable after it exists.
Use cases
What Teams Run Perplexity Rank Checks For
Four jobs that bring teams to this endpoint, and the field or parameter behind each one.
Budgeted, repeatable visibility runs
A flat per-call rate is what makes a weekly run of 2,000 keywords a line item rather than an estimate. Store target_found, target_position and total_citations per keyword per week and the trend line builds itself.
Keep prompt_type=standard across a series. Changing the style changes the question, and the series stops comparing like with like.
Share of the citation list
all_domains_cited is the deduplicated domain list for the whole run, so one call per keyword measures the entire field rather than only your own placement. Counting appearances per competitor across a keyword set turns that into a share number.
No domain is needed. Leave it out and every citation still arrives; only the target fields and the score stay empty.
Finding which claim earned the citation
cited_text carries the passage around each reference, so you can see the specific claim that was picked up rather than only that a page was named.
Rewrite the section, re-run the same keyword, and compare the two citation lists. Both are in your own storage, so the comparison does not depend on a vendor keeping history for you.
Buying questions and deep audits
prompt_type=brand puts the query in its comparison form, so what comes back names and ranks options rather than describing a category. It is the phrasing a buyer uses, and the place where not being cited costs revenue rather than sessions.
prompt_type=deep raises the ceiling from 10 citations to 15 when you are auditing a topic and want the long tail of sources.
# One line per keyword: date, keyword, our position, total citations in the answer. DOMAIN="example.com" while IFS= read -r kw; do curl -s -G "https://apiserpent.com/api/ai/rank/perplexity" \ --data-urlencode "q=$kw" \ -d "domain=$DOMAIN" \ -H "X-API-Key: $SERPENT_KEY" \ | jq -r --arg d "$(date -u +%F)" --arg k "$kw" \ '[$d, $k, (.results.perplexity.target_position // 0), .results.perplexity.total_citations] | @csv' \ >> perplexity-citations.csv done < keywords.txt
FAQ
Perplexity Rank Tracking API Questions
position in the order of first mention, the url and domain, the page title, a normalized URL, and cited_text, the passage the reference appears in. The response also carries total_citations, the answer in response_text, the public model label, and the target fields with a score once a domain is supplied.
model field with the public Perplexity model label, currently sonar-pro. Store it alongside each result so that when the label changes, a shift in your chart is explained by your own data rather than looking like unexplained movement.
prompt_type=deep, and total_citations reports how many actually arrived. When nothing was cited, citations comes back as an empty array rather than a missing key.
visibility_score is weighted per engine and blended across the engines present in the response, and a Perplexity-only call has one engine contributing, so it tops out at 25. The cap describes the blend and says nothing about your page. Watch target_position on a single engine, and call /api/ai/rank when you want the whole 0 to 100 range.
target_match_type comes back as exact when the cited domain is the one you passed, or subdomain when a host beneath it was cited, with that host in target_matched_domain. Exact is resolved first, so your main domain wins whenever both forms appear in one answer.
GET /api/ai/rank returns all four in one response, each under its own engine name and in the same shape. The combined rate is $40.00 per 1,000 on Default, $4.00 on Growth and $2.00 on Scale, which is half the cost of four separate calls and a single wait rather than four. Use engines=perplexity,gemini for a pair; the combined rate covers any call naming more than one engine.
Start tracking Perplexity citations
free API calls, no card and no subscription. Perplexity rank checks from $1.00 per 1,000 queries, priced before you call.
Try for Free

