Documentation Pages and AI Citations on Branded Questions

When a buyer asks an AI engine about your brand, the engine answers mostly from your own site, and it treats whichever page states a fact as your documentation. On 120 branded answers from ChatGPT, Gemini, Perplexity and Claude, our own pages took 68.9% of all citations. Blog posts took 53% of those, more than our pricing, feature and home pages combined, even on questions about price.

That makes every page that mentions a product fact a documentation page, whether you wrote it as one or not. By the end of this post you'll know which page types engines cite for each kind of branded question, where the wrong answers came from, and how to build a documentation layer that engines read first. A script shows the same breakdown for your site.

Data used: 15 branded buyer prompts (10 about our brand alone, 5 comparing it with a named competitor) × ChatGPT, Gemini, Perplexity and Claude × 2 runs on 2026-10-20 (120 answers, 749 citations, web search on), collected by BugViso's AI Visibility Tracker for bugviso.com (website-audit software). Page types come from URL paths. Accuracy verdicts come from the tracker's fact check against the brand's own site.

Branded Answers Run on Your Own Pages

On branded questions, engines read the brand's site first and most. 117 of 120 answers cited at least one of our pages, and the share of citations held up on every engine:

This is the opposite of unbranded questions, where our site got a small share of citations and engines leaned on list pages and third parties. Our post on AI citations to your own website covers that side. Once a buyer names you, your site is the main evidence, which is also why branded and unbranded prompts must be reported separately.

So the quality of branded answers depends on what your pages say, and on which of them an engine finds first.

AI Citations by Page Type: Documentation Pages, Blog, Pricing

Blog posts led or tied on every branded question except refunds. Engines cited 85 different URLs on our site. By page type:

Among the blog citations, 169 went to guides and how-to posts, 87 to comparison and alternatives posts, and 20 to "best tools" lists. Sixty-five different posts were cited.

Here's how that played out by question:

On "how much does it cost", 22 of 40 own-site citations were blog posts and 4 were the pricing page. The engine answered a pricing question mostly from articles that mention our pricing in passing.

Only the refund question went mostly to the page that owns the fact. Refund policies live on one legal page and are rarely repeated in blog posts, so there was nothing else to read.

Why Engines Read Your Blog as Documentation

Blog posts outnumber product pages, match more question wording, and often restate product facts. Three mechanics push them up:

1. Volume. A site with 200 posts and 10 product pages offers 20 chances to match a query in the blog for every one on a product page.
2. Query match. Engines rewrite the buyer's question into search queries. A post titled around "AI crawler access" matches "how does BugViso check AI crawler access" better than a feature page titled with a product name.
3. Restated facts. Comparison posts and guides mention plans, prices and features to make a point. Each restatement is a copy of the fact that can go out of date.

None of this is wrong in itself. A good guide is a fine source. The risk is drift: product pages get updated when prices change, blog posts usually don't.

💡 Rule of thumb: if a product fact appears on more than one page, the engine may quote any of them. Either keep every copy current or link every copy to the one page that owns the fact.

Where the Wrong Answers Came From

The errors on branded questions were about prices and plans. BugViso's fact check flagged 9 inaccurate claims across the 120 branded answers, against 280 accurate ones; 330 more couldn't be checked against the site. All 9 were about pricing, plan names, scan allowances or rollover terms.

Looking at what each wrong answer cited:

• Two Claude answers cited only blog guides from our site, and no pricing page. Both concluded that pricing is per report only, with no subscription. Without the pricing page in view, a partial picture became a wrong claim.
• The other seven cited our pricing page. One was a false alarm: a correct claim about our $49 tier that the checker's short fact sheet couldn't confirm. The other six still got it wrong. Two turned the $49 tier our pricing page highlights as "Best Value" into the starting price, one called it the first white-label tier, two named a plan type we had already retired, and one stretched the 60-day rollover to "60–90 days". Reading the right page doesn't guarantee reading it right.

So two fixes are needed. Product facts must be complete wherever they appear, so a guide that mentions one option links to the full pricing. And the canonical page has to state each fact unambiguously, so a highlighted tier can't be read as the cheapest one and a retired plan appears nowhere. Our AI brand accuracy audit has the full error analysis.

Build a Documentation Layer Engines Read First

Give every product fact one canonical page, make that page easy to match, and make every other page point to it. For a software product, that's a small set of pages:

Then work the blog into it:

1. Link product facts in posts to the canonical page. "Plans start at…" becomes a link to /pricing with the current number, or no number at all.
2. Title feature pages the way buyers ask. "How BugViso checks AI crawler access" is more likely to match the branded question than a page called "GEO Engine".
3. Show dates. Google's guidance on publication dates asks for a visible date and a matching dateModified in structured data. Engines reading two conflicting copies need a reason to prefer one.
4. Describe the product in structured data. SoftwareApplication markup with offers puts the price in a machine-readable field; Google documents the required properties for software app structured data. It doesn't guarantee an engine uses it, but it's one more consistent copy.
5. Retire facts actively. When a plan is retired, search your own site for its name and update every post that mentions it, the same week.

See Which Pages Engines Cite for Your Brand

This script reads an answer export, keeps branded answers, and prints your own-site share of citations per engine, the page types cited (with your own path rules via --type), the page types per prompt, and the most-cited URLs. Standard library only.

#!/usr/bin/env python3
"""Which of your pages do AI engines cite when buyers ask about your brand?
Own-site share of citations, page types per engine and per prompt, and the most-cited URLs.

Usage: python3 branded_pages.py answers.csv --domain acme.com [--type /docs/=docs --type /changelog=changelog]
answers.csv columns: engine, prompt, cited_urls (space-separated), branded (1/0; only branded rows are read).
"""
import argparse, csv
from collections import Counter, defaultdict
from urllib.parse import urlparse

DEFAULT_TYPES = [("/blog/", "blog"), ("/docs", "docs"), ("/help", "docs"), ("/pricing", "pricing"),
                 ("/features", "features"), ("/terms", "legal"), ("/privacy", "legal"), ("/refund", "legal"),
                 ("/about", "about"), ("/contact", "contact")]

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("csv"); ap.add_argument("--domain", required=True)
    ap.add_argument("--type", action="append", default=[], help="path prefix=label, checked before the defaults")
    a = ap.parse_args()
    types = [tuple(t.split("=", 1)) for t in a.type] + DEFAULT_TYPES
    def page_type(path):
        if path in ("", "/"):
            return "home"
        return next((label for prefix, label in types if path.startswith(prefix)), "other")
    host = lambda u: (urlparse(u).hostname or "").lower().removeprefix("www.")
    total = Counter(); own = Counter(); by_type = Counter(); urls = Counter()
    per_prompt = defaultdict(Counter); answers = citing = 0
    for r in csv.DictReader(open(a.csv, newline="", encoding="utf-8")):
        if r.get("branded") != "1":
            continue
        answers += 1
        mine = [u for u in r["cited_urls"].split() if host(u) == a.domain or host(u).endswith("." + a.domain)]
        total[r["engine"]] += len(r["cited_urls"].split()); own[r["engine"]] += len(mine); citing += bool(mine)
        for u in mine:
            path = urlparse(u).path.rstrip("/")
            t = page_type(path)
            by_type[t] += 1; urls[path or "/"] += 1; per_prompt[r["prompt"][:58]][t] += 1
    n_own, n_all = sum(own.values()), sum(total.values())
    print(f"{answers} branded answers, {citing} cite your site; own-site citations {n_own}/{n_all} = {100 * n_own / max(1, n_all):.1f}%")
    print("by engine: " + ", ".join(f"{e} {own[e]}/{total[e]}" for e in sorted(total)))
    print("page types: " + ", ".join(f"{t} {n} ({100 * n / max(1, n_own):.0f}%)" for t, n in by_type.most_common()))
    print("\nper prompt (own citations by page type):")
    for p, c in sorted(per_prompt.items(), key=lambda kv: -sum(kv[1].values())):
        print(f"  {p:<58} " + ", ".join(f"{t} {n}" for t, n in c.most_common(4)))
    print("\nmost-cited URLs: " + ", ".join(f"{u} {n}" for u, n in urls.most_common(8)))

if __name__ == "__main__":
    main()

The first three lines of its output on our export:

120 branded answers, 117 cite your site; own-site citations 516/749 = 68.9%
by engine: chatgpt 35/58, claude 59/106, gemini 101/135, perplexity 321/450
page types: blog 276 (53%), features 60 (12%), pricing 48 (9%), home 46 (9%), other 26 (5%), contact 21 (4%), legal 20 (4%), about 19 (4%)

If you have a docs subdomain, pass --domain as the registered domain; subdomains are counted as yours. Needs Python 3.9 or later.

How BugViso Shows Which Pages Engines Cite About You

BugViso's AI Visibility Tracker keeps every URL each engine cites, types your own domain as "own", and reports your own cited URLs alongside the top cited domains. Branded prompts are reported in their own split, so you can see how engines describe you when buyers ask about you by name, separately from whether they name you unprompted.

Each answer that mentions your brand also goes through a fact check against a fact sheet built from your site: up to six claims per answer, each marked accurate, inaccurate or unverified, with a correction for the inaccurate ones. Repeated wrong claims are grouped into issues with the engines that made them, and the action plan's fix-the-facts item can draft a key-facts page from your site. The accuracy check and source lists are part of the AI visibility tracker.

Documentation Mistakes That Feed Wrong Answers

Product numbers in evergreen posts. A 2025 guide that says "plans start at $X" will be quoted in 2027. Link to the pricing page instead of restating it.

Partial facts in focused posts. A post about pay-per-report pricing that never mentions the monthly plans can lead an engine to say there aren't any, as two of our wrong answers did.

Retired plans left in comparison posts. Comparison posts get cited on "us vs them" questions, exactly where a stale plan does the most damage.

Help content behind a login or in a widget. If the only copy of a fact is inside an app or a chat widget, engines can't read it and will fall back to whatever page restates it.

Frequently Asked Questions

Which pages do AI engines cite when someone asks about my brand?

Mostly your own: 68.9% of citations in our 120 branded answers. Within your site, engines cited blog posts most (53% of own-site citations), then feature, pricing and home pages. Whichever page states a fact can become the source.

Do AI engines read documentation pages?

Yes, when the documentation is public, crawlable and matches how buyers ask. Pages behind logins or in app widgets can't be read. Title docs and feature pages with the question a buyer would ask, and state the facts in plain text.

Why does ChatGPT quote my old blog post instead of my pricing page?

Because the post matched the search query, or the engine's index held it while the pricing page wasn't retrieved. Link product facts in posts to the canonical page, keep a visible updated date, and remove retired plan names from old posts.

How do I stop AI from giving wrong facts about my product?

Give each fact one canonical, dated page, make every other mention link to it, and update every copy when the fact changes. Then check what engines say: in our data, all 9 flagged claims were pricing or plan details.

Do I need a separate docs site for AI search?

No. You need one clear, public page per product fact. A docs section is a tidy way to provide that for software, but a well-titled feature page or help article does the same job.

Treat Every Page That States a Fact as Documentation

Engines answer branded questions from your own site, and from your blog more than your product pages, so give each fact one canonical page and keep every copy of it current. BugViso's AI visibility tracking lists the pages engines cite about you and fact-checks what they say, so the stale copies show up as soon as an engine quotes them.