Perplexity Citations per Answer: What the 15 Sources Mean

Perplexity attached 15 sources to 96 of our 100 API answers: the full result set of about three web searches, five results each. That's an average of 14.4 citations per answer, seven times ChatGPT's. But in 96 of those answers, none of the 15 sources was tied to a specific sentence. The list shows what Perplexity read, not what it quoted.

That changes how you read Perplexity data. A source list is a retrieval signal, and being in it is not the same as being recommended. In our data, our domain appeared in 18 unbranded answers' source lists, and our brand was named in 12 of them. This post explains where the 15 comes from, what the order means, how much the list changes between runs, and how to read a Perplexity response yourself.

Data used: 50 buyer prompts × 2 runs on 2026-10-20 = 100 Perplexity answers (sonar via Perplexity's Agent API, web search on), plus the same prompts on ChatGPT, Gemini and Claude for comparison. Collected by BugViso's AI Visibility Tracker for bugviso.com against five anonymised competitors. Unless noted, tables use the 70 unbranded answers.

Where Perplexity's 15 Citations per Answer Come From

Perplexity's Agent API returns a search_results item before the answer. It lists the queries Perplexity ran and the results each one returned. According to the web search tool documentation, max_results is a total budget per call, split across the reformulated queries (roughly ceil(max_results / number_of_queries)). The docs describe the search_results entries as "the source of truth for citations".

Our 100 answers show that budget at work:

Every answer that searched at all came back with exactly 15 sources, about 5.3 per query. The 4 answers without sources ran no search. So "14.4 citations per answer" isn't a sign that Perplexity cites thoroughly. It's a fixed retrieval budget divided by the number of queries.

Sources Aren't Footnotes

The answer text can point to individual results with bracketed markers like [1][2], each matching a result's id. Perplexity's docs say it plainly: "Whether the model adds markers to the answer is prompt-dependent". Our tracker asks buyer questions exactly as a buyer would, without asking for markers, and the answers came back like this:

So for 96 answers, the honest reading is "Perplexity consulted these 15 pages". A tracker that counts all 15 as citations will show far more citations for Perplexity than for ChatGPT, whose url_citation annotations are tied to specific sentences (OpenAI web search docs). Compare citation counts within an engine, not across engines.

How the engines compare on the same 70 unbranded prompts:

What's in the 15

The source lists are wide and shallow. Across the 70 unbranded answers there were 706 distinct URLs on 343 domains, and 212 of those domains appeared only once. The ten most frequent domains took just 32% of all citations. Each answer drew on about 10 distinct domains on average, with 4.4 of its 15 results repeating a domain already in the list.

Competitors' own sites and ours both appear more often near the top of the list than further down. That's the first sign that order matters.

Position in the List Predicts Being Named

When Perplexity named our brand in an unbranded answer (12 times), our own site was always in the 15 sources. It was usually near the top:

Ten of the 12 answers that named us had our page in the top five results. Five of the 6 answers that listed our site without naming us had it at position 6 or lower. On branded prompts, our site was the first result in 28 of 30 answers.

Competitors show the same pattern from the other side. Competitor B's site appeared in the sources of 19 unbranded answers, but Competitor B was named in only 7. Competitor E: 14 appearances, 3 namings with its site present, 11 without being named at all. Being retrieved is necessary, but it doesn't decide the answer. Ranking near the top of one of Perplexity's three queries does more.

The 15 Change Every Time

The source lists churn heavily. For the same unbranded prompt asked twice, 23 minutes apart, the median overlap between the two sets of source URLs (Jaccard similarity) was 0.15. Most of the 15 sources were different on the re-ask, even though the brands named changed much less. In our answer-consistency test, 80% of Perplexity's shortlists of tracked brands stayed the same.

Two consequences:

1. Don't chase single source appearances. A page in today's list may be gone tomorrow. Count how often a domain appears across a week of answers.
2. The queries are the stable part. Perplexity ran three queries of about 9 words each, close to the buyer's wording. Pages that rank for those query shapes keep coming back even as individual results rotate.

The Three Queries Behind Every Answer

Perplexity doesn't search for the buyer's sentence. It writes about three shorter queries, each a different angle on the question. For "which white-label audit software lets me schedule monthly re-scans for each client", the first run searched for:

white label SEO audit software schedule monthly scans per client
white label website audit recurring monthly schedule client reports
site audit tool schedule crawls monthly white label

That answer named our brand. Across all 196 unbranded queries, about half the words in a typical query also appeared in the buyer's prompt (median 50%). The rest were synonyms Perplexity added: "recurring" for "monthly", "crawls" for "re-scans", "pricing" for "cost". Only 14% of queries carried a year, and only 5% used list words like "best" or "vs", so Perplexity mostly searches for the task, not for roundups.

That's why it reaches niche vendor pages. Of its unbranded sources, 18.4% were tracked vendors' own sites (competitors and ours), against 6.7% on Gemini and 5.6% on Claude. ChatGPT's share was higher (21.8%) but drawn from only 2 sources per answer. A vendor page that describes one task in the buyer's own vocabulary matches one of the three queries directly.

Why Perplexity Was Our Best Engine

Perplexity named our young brand in 12 of 70 unbranded answers, more than ChatGPT (6), Gemini (3) and Claude (0) combined. It was the only engine where we led every tracked competitor on mention rate (17.1% vs 12.9% for the closest).

The data above explains it. Perplexity runs three task-shaped queries, reads 15 results from about 10 domains, and gives vendor pages a fair share of those slots. When our page ranked in the top five for one of the queries, the answer usually named us. Engines that search once for "best X tools" never reach that page. For the opposite case, see why Claude skips small brands.

The lesson for a challenger brand: Perplexity is the engine where page-level work shows up first, because it reads the most pages per answer. Use it as your early indicator, and don't assume the other engines will follow at the same pace.

Read a Perplexity Response Yourself

Save a raw Agent API response, then run the script below. It lists the queries, counts results per query, marks which results the answer actually references (by [n] marker or annotation), and highlights your domain's position.

# Uses your own Perplexity API key; one call costs a few tenths of a cent at sonar rates.
curl -s https://api.perplexity.ai/v1/agent \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "perplexity/sonar", "input": "which website audit tool is best for a small agency",
       "tools": [{"type": "web_search"}]}' > response.json

#!/usr/bin/env python3
"""Read a saved Perplexity Agent API response: which queries ran, how many results each returned,
which results the answer actually references, and where your domain sits in the list.

Usage: python3 perplexity_sources.py response.json --domain acme.com [--brand Acme]
"""
import argparse, json, re
from urllib.parse import urlparse

MARKER = re.compile(r"\[(?:web:)?(\d{1,3})\]")

def host(u):
    return (urlparse(u or "").hostname or "").lower().removeprefix("www.")

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("response"); ap.add_argument("--domain", required=True); ap.add_argument("--brand")
    a = ap.parse_args()
    data = json.load(open(a.response, encoding="utf-8"))
    queries, results, text, annotated = [], [], "", set()
    for item in data.get("output") or []:
        if item.get("type") == "search_results":
            queries += item.get("queries") or []
            results += item.get("results") or []
        elif item.get("type") == "message":
            for part in item.get("content") or []:
                text += part.get("text") or ""
                annotated |= {x.get("url") for x in part.get("annotations") or []}
    marked = {int(m) for m in MARKER.findall(text)}
    print(f"queries ({len(queries)}): " + " | ".join(queries))
    print(f"results: {len(results)} ({len(results) / max(1, len(queries)):.1f} per query), "
          f"{len({host(r.get('url')) for r in results})} domains")
    print(f"answer: {len(text.split())} words, {len(marked)} inline markers, {len(annotated)} annotations")
    if not marked and not annotated:
        print("No markers or annotations: every result is a candidate source, none is tied to a sentence.")
    print(f"\n{'#':>3}  {'ref':<4}{'domain':<32}title")
    for pos, r in enumerate(results, 1):
        ref = "yes" if (r.get("id") in marked or r.get("url") in annotated) else ""
        mine = "  <-- you" if host(r.get("url")).endswith(a.domain.lower()) else ""
        print(f"{pos:>3}  {ref:<4}{host(r.get('url'))[:31]:<32}{(r.get('title') or '')[:50]}{mine}")
    if a.brand:
        named = re.search(r"(?<![\w-])" + re.escape(a.brand) + r"(?![\w-])", text, re.I)
        print(f"\n{a.brand} named in the answer: {'yes' if named else 'no'}")

if __name__ == "__main__":
    main()

python3 perplexity_sources.py response.json --domain acme.com --brand "Acme"

We tested the parser on two saved fixtures in the documented response shape, one with [1]/[3] markers and one without. It marked the referenced results correctly in the first and printed the "no markers" note in the second. If you append "Cite your sources inline using bracketed markers" to the prompt, as the docs suggest, the ref column fills in. Keep in mind that a prompt asking for citations is no longer the question a buyer would type.

How BugViso Tracks Perplexity Citations

BugViso's AI Visibility Tracker asks every buyer prompt on Perplexity through the Agent API with web search on, using the brand's country for location, and stores the queries and sources with each answer. It reads citations in a fixed order of preference: URL annotations first, then inline [n] markers mapped to result ids, and only when neither exists, the full result list. Answers recorded that way are flagged, and the answers view says so next to the sources: "No inline citations; consulted sources shown."

Every cited domain is typed (your site, competitor, review site, forum, news, reference, directory or other). Citation metrics are computed per engine before any average, so the engine scorecard shows Perplexity's citation coverage next to ChatGPT's instead of blending their very different lists. Citation coverage counts answers that cite your domain at least once, not raw citation counts, so a 15-source list can't inflate it. The per-engine source view is on the AI visibility tracker page.

Limitations

API vs app. The consumer app shows numbered sources and can add personalisation and follow-ups. API answers approximate a fresh session.

One model, one day. All answers came from sonar on 2026-10-20. Presets with deeper search can change the query count and budget.

Markers depend on the prompt. A different system prompt or user instruction would produce inline markers. Our numbers describe plain buyer questions.

Source types come from a classifier. Some vendors that publish free graders were typed as review sites, so read the "review and grader" row as an upper bound. Our review sites post has a stricter count.

Frequently Asked Questions

How many sources does Perplexity cite per answer?

In our 100 API answers, Perplexity attached exactly 15 sources to every answer that ran a web search (96 of 100), an average of 14.4. That matches about three queries with five results each.

Are Perplexity's sources the pages it actually quoted?

Not necessarily. Unless the prompt asks for inline markers, the answer usually doesn't tie sentences to sources. In our data, 96 answers had no markers or annotations, so the 15 sources are the pages Perplexity retrieved.

Does appearing in Perplexity's sources mean it recommends you?

No. Our site appeared in 18 unbranded answers' sources, and we were named in 12. One competitor appeared in 19 answers' sources and was named in 7. A top-five position made being named much more likely.

Why does Perplexity cite different sources each time?

Each answer runs fresh searches. The same prompt asked twice, 23 minutes apart, shared a median of 15% of its source URLs. Brand shortlists were far more stable than the source lists.

How do I get into Perplexity's citations?

Rank in the top five results for the specific, roughly 9-word queries Perplexity writes from buyer questions. Pages that answer one question directly, with prices, audiences and differentiators stated in plain text, are what it surfaces. Make sure PerplexityBot can reach them; Perplexity documents its crawlers on its crawler page. Our post on content extractability covers the structure.

Read the List as Retrieval, Not Endorsement

Perplexity's 15 sources tell you what it read. Your position in that list, and whether the answer names you, tell you what it used. Track both per engine and over many runs, which is how BugViso's AI visibility tracking treats Perplexity's citations.