The Cheapest Perplexity Rank Tracking API for Developers

Every source a Perplexity answer cited, your position in that list, and a visibility score. From $1.00/1K.

Try for Free View Documentation
From $1.00/1K queries Free to start One price per call, known upfront Citations with positions

Call GET /api/ai/rank/perplexity with a keyword and, optionally, a target domain. One flat charge per call, and no per-token billing on top.

Run a live Perplexity rank check

One real call, no signup and no key. The cited sources and the raw JSON arrive together.

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.

GET /api/ai/rank

All four engines

from $2.00
/1K queries (Scale tier)
  • 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
Default$40.00/1K queries
Growth$4.00/1K queries
Scale$2.00/1K queries
Compare engines →

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.

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.

cURL — Perplexity rank check
# 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"
Python — requests
# 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.js — fetch
// 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(', '));
JSON Response (partial)
{
  "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.

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)

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.

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.001 call = 1 Perplexity answerOne-time $500 deposit, permanentFree to start
Oxylabs$0.95Per result, 24 data pointsA custom quote. Its cheapest rate on a plan with a published price is $1.00 on $999 a month2,000 results
SearchApi.io$1.00Per search$5,000 a month100 requests
cloro.dev$1.224 credits per request$5,000 a month500 credits a month
Bright Data$1.30Per record$499 a month5,000 records a month
Perplexity Sonar (own API)$5.00 to $12.00 plus tokensPer request, priced by context size$1 per million tokens in each direction on topNone
Perplexity Sonar Pro (own API)$6.00 to $14.00 plus tokensPer request, priced by context size$3 and $15 per million tokens on topNone
Perplexity Search API$5.00Per requestReturns web results, not a Perplexity answerNone
DataForSEO LLM ScraperDoes 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.

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.

Bash — weekly Perplexity citation log
# 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

Perplexity Rank Tracking API Questions

A Perplexity-labeled answer for your keyword together with its cited sources. Each entry gives you 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.
One flat number per call: $20.00 per 1,000 queries on Default, $2.00 on Growth, $1.00 on Scale. Growth is unlocked by depositing $100 once and Scale by depositing $500 once, and a tier is never taken away afterwards. There is no recurring charge of any kind, and a new account can spend its free API calls here.
Perplexity’s Sonar models bill on two axes at once: a per-request fee that changes with the amount of context, from $5.00 to $12.00 per 1,000 requests, plus $1 per million tokens in each direction. Sonar Pro runs from $6.00 to $14.00 per 1,000 with higher token rates. The design is reasonable and hard to budget against, because the cost of an answer is only knowable once it exists. Here the charge is one flat number per call at your tier.
No, and it is the number most likely to be mistaken for one. Perplexity’s Search API is $5.00 per 1,000 requests and returns web results rather than a Perplexity answer. There is no answer text, so there is nothing to be cited in and no citation ordering to track. It is a different product, priced for a different job.
Every response carries a 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.
The ceiling is 10 with the default prompt style and 15 with 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.
Because 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.
Yes, and the match type is reported rather than hidden. 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.
Yes. 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.
Plan for 10 to 25 seconds. That is well above a search call and entirely normal here, so give the client a timeout of at least 60 seconds. If you want more than one engine, run them through the combined endpoint: less money than the same engines called individually.

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

Related guides

More on measuring citations in Perplexity and the engines beside it.

How Answer Engines CiteWhat separates the four when they pick sources. Citation RepeatabilityHow much a citation list moves between identical runs. AI Visibility MetricsWhich numbers are worth putting on a dashboard. 14 AI Rank Trackers AuditedWhich tools publish their method, and which do not. Citation Tracker in PythonA runnable tracker across all four engines. Brand SERP MonitoringSearch engines and answer engines on one dashboard. AI Rank APIAll four engines behind one endpoint and one key. Gemini Rank APIThe same response shape for Gemini answers.