Short answer. Nobody outside Perplexity can tell you, with evidence, why one page gets cited and another does not. The official developer documentation says few things: PerplexityBot exists to make sites appear and be linked in search results and allowing it is recommended, Perplexity-User visits pages when a person asks a question. From this follows a single documented prerequisite: do not block PerplexityBot. Everything else, from the structure of the text to freshness, circulates as a “technique”, but is at best a reasonable conjecture. This article separates what is documented from what is plausible and from what is merely repeated, gives you a poll you can repeat with the noise measured, and closes the series with a recap of the eight articles.
Three columns: documented, plausible, repeated
| Documented by the provider | Plausible but not demonstrated | Repeated by third parties, with no primary source that I opened |
|---|---|---|
| PerplexityBot makes sites appear and be linked in the results and allowing it in robots.txt is recommended. Perplexity-User visits pages at a user's request and generally ignores robots.txt. Changes to robots.txt take up to 24 hours. The IP ranges are published in two JSON files. | Clear text, the answer at the top, visible dates, complete HTML without depending on JavaScript, stable URLs, a sitemap with true dates, an explicit author identity. | Weights of “signals” (authority, freshness, structure), preference for “community” sources, ideal paragraph length, average number of citations per answer, whether or not the crawler executes JavaScript. |
The middle column is not a list of tricks: it is a list of things that improve the site for readers and for any crawler. The criterion for including them is that if the conjecture is wrong, you have lost nothing: writing an answer in the first lines of a page, or showing the update date, serves whoever reads anyway. Practices that cost a lot for a hypothetical benefit (massive rewrites, pages made on purpose for engines) I do not recommend.
What can really be measured
Four measures, each with its limit. None of them tells you “how much you are cited”:
- Crawler visits (server logs). How many PerplexityBot requests per URL, with the addresses verified against the official file, as in article 7. Limit: being visited does not mean being cited.
- Visits from perplexity.ai (analytics). The people who clicked a source. Limit: it undercounts, because not every citation is clicked and not every browser passes the referrer.
- A poll with the Search API. Your questions, filtered on your domain, recording whether your URLs appear among the results. Limit: it measures whether your pages are retrievable through the Search API, not what the application cites.
- Manual tests. The same questions in the application. Limit: answers vary from one test to the next, and a single appearance proves nothing and does not count as a trend.
The four measures look at different points of the same chain (visit, index, answer, click) and cannot be added up: a high number in the first and nothing in the third is information, not a contradiction. For the third point, the “Search API: overview” page I read does not say that its index and ranking coincide with those of the consumer application, so I do not assume it. The poll is the only measure you can repeat identically every week, and it is the one we build now.
A repeatable poll, and how much noise there is
The program below contains the logic of the poll and the test against a fake search: the function search is injected and here it returns hand-built lists (two results from other sites and, for some questions, one from your domain example.com). Nothing it prints comes from Perplexity. The function poll records for each question how many URLs from your domain appear, and share is the fraction of questions with at least one URL of yours. Then it measures the noise: if the two polls had the same true probability of success (0.5 for simplicity), by how many questions of difference would they fool you?
"""Retrievability poll: the logic, tried against a FAKE search (it is not Perplexity).
The `search` function is injected: in production it would be the call to the Search API, here it is
a hand-built list of results. Prices from Perplexity's Pricing page (2026-11-13).
"""
import math
import random
from fractions import Fraction
from types import SimpleNamespace as Result
from urllib.parse import urlsplit
DOMAIN = "example.com"
QUESTIONS = [
"how to choose hiking boots", "average weight of a backpack for three days",
"how to wash a waterproof jacket", "two-person tent or three-season tent",
"how to read a hiking map", "what to put in a first-aid kit",
"difference between down jacket and fleece", "how to waterproof shoes",
"sleeping bag comfort temperature", "how much water to carry on a day hike",
"telescopic or folding trekking poles", "how to repair a torn tent",
"boots or low shoes in summer", "how to lace boots tightly for the descent",
"technical socks in wool or synthetic", "how to choose a 40-litre backpack",
"headlamp with how many lumens", "how to dry wet gear",
"how to plan a three-day route", "light gloves for spring",
]
def fake_search(your_indices):
"""For the questions in the indices it also returns a URL from your domain."""
def search(question):
i = QUESTIONS.index(question)
others = [Result(url=f"https://other-{i}.test/a"), Result(url=f"https://magazine-{i}.test/b")]
mine = [Result(url=f"https://{DOMAIN}/guide-{i}")] if i in your_indices else []
return others + mine
return search
def poll(search, questions, domain, day):
rows = []
for question in questions:
yours = [r.url for r in search(question) if (urlsplit(r.url).hostname or "").endswith(domain)]
rows.append({"date": day, "question": question, "n_your_urls": len(yours), "urls": yours})
return rows
def share(rows):
return sum(1 for r in rows if r["n_your_urls"] > 0) / len(rows)
def prob_difference(n, p, threshold):
"""Exact probability that two polls of n questions, with the same true p, differ by at least `threshold` questions."""
pm = [math.comb(n, k) * p**k * (1 - p) ** (n - k) for k in range(n + 1)]
return sum(pm[a] * pm[b] for a in range(n + 1) for b in range(n + 1) if abs(a - b) >= threshold)
if __name__ == "__main__":
a = poll(fake_search(set(range(0, 18, 2))), QUESTIONS, DOMAIN, "2026-11-06")
b = poll(fake_search({0, 1, 2, 4, 6, 8, 10, 12, 13, 14, 16}), QUESTIONS, DOMAIN, "2026-11-13")
print(f"week A: {share(a):.2f} week B: {share(b):.2f} difference {share(b) - share(a):+.2f}")
n, p = len(QUESTIONS), 0.5
for threshold in (2, 6):
print(f"if nothing had changed, difference >= {threshold}/{n} questions with probability {prob_difference(n, p, threshold):.3f}")
rng = random.Random(11) # check: fixed-seed simulation
trials = 20000
sim = sum(abs(sum(rng.random() < p for _ in range(n)) - sum(rng.random() < p for _ in range(n))) >= 2
for _ in range(trials)) / trials
print(f"simulation ({trials} pairs): {sim:.3f} against exact {prob_difference(n, p, 2):.3f}")
assert abs(sim - prob_difference(n, p, 2)) < 0.01
requests_month = len(QUESTIONS) * 4 # 20 questions a week
standard = Fraction(requests_month) * Fraction("5.00") / 1000
fast = Fraction(requests_month) * Fraction("1.00") / 1000
print(f"{requests_month} requests a month: ${float(standard):.2f} standard, ${float(fast):.2f} with search_type fast")
# Command: python3 poll.py
# Output:
# week A: 0.45 week B: 0.55 difference +0.10
# if nothing had changed, difference >= 2/20 questions with probability 0.636
# if nothing had changed, difference >= 6/20 questions with probability 0.081
# simulation (20000 pairs): 0.634 against exact 0.636
# 80 requests a month: $0.40 standard, $0.08 with search_type fast
The two fake polls differ by 0.10, that is two questions out of twenty: if nothing had changed, a gap of at least two questions happens with probability 0.636, so almost two times out of three. You need much larger differences (six questions, 0.30) to get down to 8%. The exact value comes from the convolution of two binomials and the fixed-seed simulation over twenty thousand pairs confirms it (0.634 against 0.636). The practical conclusion is one of caution: with twenty questions, treat as significant only wide and lasting variations, not the comparison between two weeks. The cost, with the prices on the Pricing page, is 0.40 dollars a month in standard mode (80 requests at 5.00 dollars per thousand) or 0.08 with search_type: "fast".
To go from fake to real you only need to replace the injected function with a call to the Search API. The scheme below uses only parameters from the “Search API: overview” page: query, max_results (from 1 to 20), country (ISO 3166-1 alpha-2 code) and search_domain_filter (up to 20 domains, in inclusion-only or exclusion-only mode with the prefix -). It is a scheme to adapt: I did not run it, I have no key, I never sent it. With the filter on your domain you ask “among this site's pages, which are retrievable for this question?”, not “does my site beat the others?”: for the second you would have to search without a filter and look at the position.
from perplexity import Perplexity # pip install perplexityai (version 0.46.1 on 13 November 2026)
client = Perplexity() # reads PERPLEXITY_API_KEY from the environment
def real_search(question):
return client.search.create(
query=question,
max_results=10,
country="IT", # ISO 3166-1 alpha-2 code: Italy
search_domain_filter=["example.com"], # allowlist: only your domain
).results
What I can validate without the product is the shape. The program below reads the scheme as text, parses it with ast without importing the package, and checks the parameter names against the documented list and the limits above. I also try it on a deliberately wrong copy (wrong_sample.py: a model parameter that does not exist, max_results=50 and country="Italy"). A valid shape does not prove that the answer is what you expect: it proves only that you do not send a malformed request.
"""Checks only the SHAPE of the request in search_schema.py: it does not import the package, it sends nothing.
Parameters and limits from Perplexity's "Search API: overview" page, read on 2026-11-13.
"""
import ast
import sys
PARAMETERS = {
"query", "max_results", "search_type", "max_tokens", "max_tokens_per_page",
"search_domain_filter", "search_language_filter", "search_recency_filter",
"search_after_date_filter", "search_before_date_filter",
"last_updated_after_filter", "last_updated_before_filter", "country",
}
def create_calls(tree):
for node in ast.walk(tree):
if (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
and node.func.attr == "create"):
yield node
def check(code):
tree = ast.parse(code) # valid syntax?
problems = []
for call in create_calls(tree):
kw = {k.arg: k.value for k in call.keywords}
unknown = set(kw) - PARAMETERS
if unknown:
problems.append(f"undocumented parameters: {sorted(unknown)}")
if "max_results" in kw and not 1 <= ast.literal_eval(kw["max_results"]) <= 20:
problems.append("max_results outside 1-20")
if "country" in kw:
c = ast.literal_eval(kw["country"])
if not (len(c) == 2 and c.isalpha() and c.isupper()):
problems.append("country is not an ISO 3166-1 alpha-2 code")
if "search_domain_filter" in kw:
d = ast.literal_eval(kw["search_domain_filter"])
if len(d) > 20:
problems.append("more than 20 domains in the filter")
if len({x.startswith("-") for x in d}) > 1:
problems.append("mixed filter: one mode per request")
yield sorted(kw), problems
if __name__ == "__main__":
for path in sys.argv[1:]:
with open(path, encoding="utf-8") as f:
found = list(check(f.read()))
print(f"{path}: {len(found)} create() call")
for parameters, problems in found:
print(" parameters:", ", ".join(parameters))
print(" problems:", problems or "none")
print("no request sent")
# Command: python3 request_shape.py search_schema.py
# Output:
# search_schema.py: 1 create() call
# parameters: country, max_results, query, search_domain_filter
# problems: none
# wrong_sample.py: 1 create() call
# parameters: country, max_results, model, query, search_domain_filter
# problems: ["undocumented parameters: ['model']", 'max_results outside 1-20', 'country is not an ISO 3166-1 alpha-2 code']
# no request sent
The right scheme passes with no problems, the wrong copy gets three flagged, one per error. The package name and the shape of the import come from the Search API page (pip install perplexityai, imported as perplexity); version 0.46.1 is the latest on the PyPI registry on 13 November 2026. Record every run with the date in the file, and treat the numbers as a time series with a known margin of error, not as a score.
What I choose not to write
- Percentages of citation improvement after this or that change: I found no independent, reproducible measurements.
- “Perplexity does not execute JavaScript” as a fact: I met it as a repeated claim, not in the official documentation. Publishing complete server-side HTML remains good practice regardless, but I do not present it as a cause of citations.
- A checklist for “ranking on Perplexity”: if you sell it as a guarantee, it is selling you a conjecture.
- Data from this site. The site allows PerplexityBot in
robots.txt, but I do not publish citation numbers because I have not measured them with a method that would withstand criticism.
These are four omissions of the same nature: a figure or a rule without a measurement that anyone can repeat. I preferred to leave the gap and declare it, because in this field an invented number travels faster than a correction. If you find an independent, reproducible measurement, that is where it is worth updating this page.
Two declared scenarios: the citation out of context
A professional firm with an in-depth blog
Hypothesis: a law firm publishes one article a month and allows PerplexityBot. What changes: publication date and date of last review at the top, the scope of the text (which law and as of which date it refers to), and the monthly poll. The expected value is not traffic: it is that whoever receives a synthetic answer with a source sees the firm's name. What goes wrong: a law changes and the article stays cited in its old version, or the answer attributes to the firm a statement the article did not make. Remedy: scheduled review, a notice at the top of aging pages, and the rule that no article replaces an opinion. Whether being cited brings clients I do not know, and I do not promise it.
The neighborhood association and the flyer
Hypothesis: a town's pro loco (local tourist association) publishes the programme of the village fair as the image of a flyer. What changes: a page with the programme written as text, date and place at the top, readable even by someone who asks an assistant “what is on this weekend in town”. What goes wrong: the date changes and the answer, for days, reports the old one: every change must be made on the page, not only on social media. And whoever looks for times or parking must open the cited source instead of trusting the summary.
The series on one page
The eight articles, in the order in which it is best to read them:
- 01 - Perplexity for developers: the map: the five APIs in one table, a first example for each, the trade-off between the Agent API and the Search API and what happened to the Sonar models.
- 02 - Perplexity Agent API: effort and citations: the effort levels, the cited sources, filters and tools, long runs.
- 03 - Perplexity Search API for your RAG: the request parameters, a pipeline with verifiable sources and the count of five queries in one request.
- 04 - From Sonar to the Agent API: migrating safely: before and after in the code, what disappears and a five-step plan.
- 05 - Perplexity MCP in Claude Code and Cursor: remote or local server, configurations without plaintext keys and the web in the assistant's context.
- 06 - Costs, QPS and 429s on the Perplexity API: the Agent API's two limits, the three 429s and a spending ceiling of your own.
- 07 - PerplexityBot and Perplexity-User: robots.txt: two agents with different rules, robots.txt according to RFC 9309 and verification from the logs.
- 08 - Getting cited by Perplexity: what's proven: this page, on what is documented, what is conjecture and how to measure the rest.
The order follows the problem in front of you: first you understand which API you need (1, 2, 3), then how to move to it from the old one (4), then how to use it from a coding assistant (5), how to cope with its limits and costs (6), how to behave toward its crawlers (7) and what to expect from visibility (8). Prices, limits and model names have a date: check them on the official documentation before sizing a service.
What you can do now
You can separate what Perplexity documents from what circulates as a technique, you can measure the crawler's visits and the retrievability of your pages with a declared margin of error, you know that with twenty questions, assuming a true probability of 0.5, two consecutive polls differ by at least two questions almost two times out of three even when nothing has changed, and you know that the only documented prerequisite is not blocking PerplexityBot. The rest I do not promise: you measure it.
← Article 7: PerplexityBot and robots.txt Back to article 1: the map →
Frequently asked questions
How do I get cited by Perplexity?
The only documented prerequisite is not blocking PerplexityBot. On source-selection criteria there is no official documentation that I found: practices like up-front answers and visible dates are reasonable but not proven.
Can I measure how often I am cited?
Not reliably from outside. You can measure crawler visits from the logs, clicks from perplexity.ai in analytics and the retrievability of your pages with the Search API, but none of these is the number of citations in the application.
Are there confirmed ranking signals for Perplexity?
Not in the documentation I read. Industry blogs list some, but I did not open primary sources that confirm them and for that reason I do not report them.
Does being cited bring traffic?
It is not demonstrated by the sources I read. For your site you can compare visits from perplexity.ai with conversions over time, bearing in mind that the measure undercounts citations that are not clicked.
Sources
- Perplexity, Perplexity Crawlers - purpose of the two agents, behavior with respect to robots.txt, time to take effect, address files; read in full on 13 November 2026
- Perplexity, Search API: overview - request parameters and limits (
query,max_results,country,search_domain_filter), theperplexityaipackage; read in full on 13 November 2026 - Perplexity, Pricing - Search API price, 5.00 dollars per thousand requests and 1.00 with fast search; read in full on 13 November 2026
- PyPI registry, perplexityai package - latest version, 0.46.1, read on 13 November 2026 from the registry's JSON interface
Commenti
Caricamento commenti...
Sign in to comment