Visibility
Citations
What counts as a citation, how one is attributed to you, and what the screen shows.

Example data shown through the app's reference panel.
What counts as a citation
A citation is one link an AI engine puts in its own answer, pointing at a
specific URL as the source for what it just said. DiscoveredBy stores one row
per link, Citation (for Claude, every page its search returned is stored as
a citation too, see Retrieved vs cited),
with its rank, sentiment and framing when the model captured them, and which prompt and run it came from
(api/models/citation.py). The rank is mostly the order the engine reported
its sources in, with a
source an engine cites without listing it numbered after its list; for
Perplexity, the two Google engines (Google AI Overviews and Google AI Mode),
ChatGPT and Gemini, it is the order the answer first cites its
sources (see Engines). On Gemini, a
page the answer quotes for several passages is one citation, and the
Google product and Google Maps place links among its sources are not
citations: they are counted as shopping and local businesses among the
answer features
(api/services/llm.py#_gemini_app_answer). A run where Google showed no AI answer
has no citations (api/services/llm.py#_ai_overview_answer). See Key terms for how
a citation differs from a mention (your brand named without a source link) and
a retrieval (a page the engine read but never linked), and
Metrics defined for how citation rate
is counted from these rows.
Daily citation metrics use the latest successful outcome for each target,
engine and day. A valid No AI answer outcome replaces an earlier answer
in those metrics; failed or in-progress retries do not. Every earlier run and
its references remain accessible in prompt history.
The admin prompt list's all-time count includes citations from all stored
completed attempts (api/services/execution_reads.py#daily_execution_filter).
All references in a response
Open View answer on a prompt's Runs tab to read the answer and its references. The same reference panel appears on the admin execution page. Each entry is labelled Web source, Shopping, or Local business, and the type selector filters the list. Shopping and local business entries do not add rows to web citation metrics.
For Gemini and ChatGPT, the panel includes returned source links
and structured product or business cards. Product names, product and merchant
IDs, explicit brand names, merchants, prices, currencies, business addresses
and listing countries appear when the provider supplies them. Missing brand
and merchant names read Not supplied; names are not guessed from a product
title or a Google URL. Brands reported for the whole answer are shown
separately, without assigning them to a product. Other engines show their
recorded citation references. Repeated source pages are merged; distinct
offers and local addresses remain separate
(api/services/answer_references.py#collect_references).
New runs save this structured reference snapshot with their normalized
response. Older runs use their saved provider payload when available, without
another provider call. A notice appears when the extraction limits omit
references or brand details
(api/services/answer_references.py#references_for_execution).
What a cited URL is
Every citation points at a CitedUrl row: the exact link, the title the
engine gave it, and when it was first and most recently seen
(api/models/cited_url.py). A CitedUrl is deduplicated by a hash of the URL
itself and is not scoped to one project, so the same page cited by five
different engines, or cited again next week, is one CitedUrl row with
several citations pointing at it, not five separate URLs. Which domain a
cited URL belongs to is decided once, when the URL is first stored, from that
URL alone.
How a citation is attributed to you
When an engine cites a URL, DiscoveredBy reduces it to its registrable
domain, the part a public suffix list says is actually registered
(example.com from https://blog.example.com/post or
https://www.example.com/post, example.co.uk from a UK subdomain), and
lowercases it (api/services/urls.py#extract_domain). That domain becomes (or
already is) a Domain row, and the citation is marked as yours when that
row's id matches the one Domain your project was set up against: the
registrable domain of the URL you gave it at project creation
(api/services/execution.py#_store_citation,
api/routers/projects.py#create_project).
That is the whole check: one domain string compared to another, done once
when the citation is stored. A subdomain of yours counts as you, because the
registrable domain is the same either way, docs.yoursite.com and
www.yoursite.com both reduce to yoursite.com. Past that, the match does
not try to be clever. For every engine, the URL used for this
comparison is the URL the engine returned, with any utm_ tracking
parameters removed (and, for the two Google engines, ChatGPT and Gemini, a
#:~:text= quote link and a YouTube timestamp removed too), so a link that has since started redirecting elsewhere
is still matched by the domain the engine gave, not by wherever it now
points (api/services/llm.py#strip_utm_params, #clean_reference_url).
Nothing here looks at the page's content,
so a syndicated copy of your article, republished verbatim on someone else's
domain, is attributed to that other domain, never to you.
What the screen shows

Example data from a fictional demo brand.
Citations counts every citation in
the window the
filter bar
sets, from completed answers that pass its engine, tag, country, persona and
language filters. Nothing on it is counted from a sample
(api/services/citations_page.py#build_citations_page,
api/routers/pages.py#CITATIONS_ACCEPTS).
It opens on Answers that cite your site: the share of collected answers
with at least one citation of your domain, and its change in points against
the prior window of the same length. That is the
citation rate, with the same
filters and comparison as the Overview's cited figure, so the two screens
agree. When an
engine was added or dropped between the two windows, the change compares only
the engines measured in both
(api/services/overview.py#compare_cited_over_engines). Under it:
- Share of all citations: your citations out of every citation in the window. It divides by citations, not answers, so it answers a different question from the headline, and the two percentages are not meant to match.
- Avg. position: where your pages sit in an answer's list of sources, on average. 1 is the first source. A citation with no recorded position is left out rather than counted as 0.
- Your pages cited: how many distinct pages of yours were cited, out of every page cited.
By engine splits the headline by collection channel. A dagger marks the
channels whose saved citations are every source the engine returned, not only
the ones the answer linked to: Claude stores every web-search result, Grok
every source xAI reports, and Perplexity's runs from before Sonar a ranked
result list. Their rates can read high for that reason
(api/services/collection.py#SURFACES_WITHOUT_ANSWER_CITATIONS).
Retrieved vs cited counts only the
sources an answer credits.
Your pages and every cited page
Both lists count a page in answers: an answer that cites a page twice is one
answer that cites it. Each row shows the share of collected answers that cite
the page with their number, how many of the prompts answered in the window
have an answer citing it, the engines that cite it, and its average position
(api/services/citations_page.py#_pages_and_totals).
Your pages that get cited lists each page of yours with a citation in the
window. Below it are the prompts that were answered in the window but never
cited one of your pages, up to 50 by name, each linking to its prompt page
(api/services/citations_page.py#_prompts, #UNCITED_PROMPTS_LIMIT).
Gaps suggests page changes for the prompts
among them where a competitor is cited.
Every page the engines cite lists every cited page, yours included, most
answers first. Narrow it to Yours, Competitors (a page on an active
competitor's domain, labelled with the competitor's name) or Everyone
else, search it by title, URL, domain or competitor name, and sort it by
page, share of answers, prompts or average position
(frontend/src/lib/citations.js#filterPages, #sortPages). Opening a page
shows up to five prompts whose answers cite it, the engines that cite it, a
link to the page, and Retrieved vs cited for this page. That screen lists
the answers that returned the page in their search results or credited it in
their text, so its answers are not the ones counted here: a Google AI
Overviews or AI Mode citation, for example, carries neither kind of evidence
(api/services/citations_page.py#TOP_PROMPTS,
api/services/source_retrieval.py#source_retrieval_url_for_project). The list holds 500
pages, your own taken first and then the most cited, so the cap drops other
sites' pages before yours. When the window holds more, a line under the list
says so, and every figure above it still counts all of them
(api/services/citations_page.py#PAGES_LIMIT).
To see which pages gained or lost citations between two periods, use Source comparison. For one row per citation, download the citations dataset from Exports, which applies the dates you choose rather than the filter bar.
Related
- Key terms: what separates a citation from a mention and a retrieval
- Metrics defined: the citation rate formula, and how domain coverage differs
- Troubleshooting: No citations yet: what a zero here does and does not mean
Last verified 2026-11-01