How to Get Cited by ChatGPT and Perplexity: The Technical Checklist

Most “how to rank in AI search” advice stays at the strategy level: build authority, publish helpful content, earn citations. All true, and all covered in our pillar guide to GEO. This article is the layer underneath that strategy: the specific technical and structural work that determines whether a page CAN be crawled, parsed, and cited at all, before content quality ever enters the conversation.

We wrote our GEO Audit Checklist to help you measure whether you’re currently being cited. This piece is the fix list for what that audit usually finds broken. If any term here is unfamiliar, our GEO and AI-search glossary defines it.

The Three Gates: Access, Structure, Authority

Every AI answer engine follows roughly the same pipeline to produce a cited response: a crawler has to reach your page, a parser has to extract a usable passage from it, and a ranking layer has to decide your passage is trustworthy enough to surface. Fail the first gate and nothing downstream matters. Fail the second and the engine may know your page exists but can’t extract anything liftable from it. Fail the third and your page is crawled, parsed, and correctly understood, but simply loses to a source the model trusts more.

Most teams jump straight to the third gate: build authority, get mentioned elsewhere, publish more content. That’s real work and it matters. But we consistently find, running GEO audits for B2B SaaS companies, that the cheapest and fastest fixes live in gates one and two: a blocked crawler, a JavaScript-only render, a wall of text with no liftable passage. Those are configuration problems, not content-quality problems, and they’re usually fixable in a day.

Gate 1: Crawler Access

ChatGPT and Perplexity each run more than one bot, and they do different jobs. Treating “AI crawlers” as one undifferentiated thing in your robots.txt is the single most common mistake we see.

OpenAI documents three separate user-agents, each independently controllable. GPTBot crawls content for model training. OAI-SearchBot crawls content to surface it in ChatGPT’s search results, and it’s the one that actually determines whether you can be cited in a ChatGPT answer. ChatGPT-User is a live, user-triggered fetch: it fires when someone asks ChatGPT a question and the model decides to visit a specific page in real time, and OpenAI is explicit that this agent’s fetches aren’t governed by search-eligibility rules the way OAI-SearchBot’s are.

Perplexity runs a comparable split. PerplexityBot is the crawler that surfaces and links your pages in its search results; Perplexity’s own documentation states it does not use this crawler for model training. Perplexity-User is the live, user-initiated fetch equivalent to ChatGPT-User, and Perplexity’s own docs note this agent “generally ignores robots.txt rules” since it’s fulfilling a specific user request, not doing discovery crawling.

The practical takeaway: if you want to be citable, allow OAI-SearchBot and PerplexityBot explicitly in robots.txt, and if your site sits behind a WAF or bot-mitigation service (Cloudflare’s bot-fight mode is a common culprit), whitelist their published IP ranges at the firewall too, since a robots.txt allow rule does nothing if the network layer blocks the request before it ever reads robots.txt. Whether you also block GPTBot for training is a separate, genuinely optional policy decision that doesn’t affect citation eligibility either way.

Gate 2: A Passage Has to Be Liftable

Assuming the crawler reaches your page, the next question is whether it can extract a clean, self-contained passage from it. Two failure modes account for most of what we find broken here.

JavaScript-only rendering. If your core content only exists after client-side JavaScript runs, and the crawler doesn’t execute that JavaScript, it sees an empty shell. This is less common on standard WordPress builds than on heavily componentized JS frameworks, but it shows up anywhere content is injected client-side: a review widget pulling ratings via JS, a pricing table rendered from a JSON API call, a FAQ accordion that only populates on click. Server-render anything you want AI engines to be able to cite; enhance with JavaScript, don’t gate content behind it.

No liftable passage. Even with clean server-rendered HTML, a page can still fail this gate structurally. If the answer to “what does this product cost” is scattered across three paragraphs of marketing copy with the actual number buried in sentence four, there’s no single passage a model can extract and quote with confidence. The fix isn’t to write worse marketing copy. It’s to also give the model an unambiguous, extractable answer near the point where the question is actually answered: a short, direct paragraph, a definition, a table row, a labeled fact. Both things can coexist on the same page.

This is exactly what a Quick Answer block does structurally (you’re reading one at the top of this article): a short, self-contained paragraph that directly answers the page’s core question, positioned before the narrative explanation. It’s not a magic tag AI engines specifically look for. It’s a discipline that happens to produce exactly the kind of liftable passage both gate 2 and human skimmers reward.

Gate 3: Structured Data Removes Ambiguity

Schema.org structured data doesn’t make content more citable by itself. No answer engine has published a mechanism where valid schema directly boosts citation odds. What it does is remove ambiguity that would otherwise cost you at the parsing stage: it tells a crawler unambiguously what type of content this is, who published it, when, and what entity it represents, instead of making the model infer that from unstructured HTML.

The schema types worth prioritizing, in order of payoff for most B2B content:

Article schema on every blog post and guide, with real author, datePublished, and dateModified fields, not placeholder or missing dates. Freshness is a real signal both engines weigh, and a page with no modification date or an obviously stale one is easy to deprioritize against a competitor who updates.

FAQPage schema on any content structured as direct question-and-answer pairs. This is the highest-leverage schema type for AI citation specifically, because it’s the format closest to how these engines already output answers: a clean question, a direct answer, already extracted for you.

Organization schema, sitewide, consistent across every page: same legal name, same URL, same logo, same sameAs links to your real social and directory profiles. This is what lets an engine resolve “MV3 Marketing” mentioned in one context to the same entity as the domain being crawled in another, which is the entity-resolution problem underneath everything else in this article.

HowTo schema where it’s genuinely accurate, meaning a real sequential process with real steps, not content that isn’t actually a linear procedure. Misapplied schema that doesn’t match the visible content is a liability, not a bonus.

What About llms.txt?

llms.txt is a real, specific proposal: a plain Markdown file at the root of your domain (/llms.txt) giving models a curated map of your most important pages, published by Jeremy Howard of Answer.AI in September 2024. It’s worth being precise about what it is and isn’t, because it gets oversold constantly in SEO content.

What it is: a genuine, documented specification with a canonical home at llmstxt.org, designed to solve a real problem: LLM context windows are too small to ingest a whole site, and raw HTML (nav, ads, scripts) wastes a huge fraction of that limited context on noise.

What it isn’t: a confirmed ranking or citation signal for ChatGPT or Perplexity. Neither OpenAI nor Perplexity has published documentation stating their production crawlers read or prioritize llms.txt files, and independent commentary in the SEO field is genuinely split: some treat it as an emerging best practice, others have argued publicly it hasn’t shown measurable adoption or effect on citation outcomes.

Our practical stance, and what we do on this site: publish it, because a clean, accurate llms.txt costs almost nothing to maintain and does no harm, but don’t treat it as a substitute for the actual work in gates 1 through 3 above, and don’t let a vendor sell you an “llms.txt optimization” package as if it were the primary lever. It isn’t, based on anything either platform has actually confirmed.

Content Signals That Compound on Top of the Technical Gates

Once a page is crawlable, parseable, and unambiguously typed, content quality is what decides whether it wins the citation over a competing source. A few things we see move that needle consistently:

First-party data and named sources. Content that cites something specific and checkable, a real study, a real number with a named source, your own original data, reads as more citable than content making the same claim in vague language. This mirrors classic E-E-A-T guidance, and it maps directly onto how these models are built: they’re trained to prefer content that looks like a reliable, checkable source over content that reads as marketing.

Distinct answers, not templated ones. If your “what is X” page reads identically in structure and phrasing to five hundred other sites’ “what is X” pages, there’s no reason for a model to prefer your version over a source it already trusts more. This is the same instinct behind why we build real per-page content instead of templated pSEO pages here. Differentiated content wins the citation; identical content just adds one more copy of the same answer to the pile.

Keeping content current. Pages with a stale dateModified and content that visibly hasn’t caught up with current pricing, current product names, or current best practices lose to a fresher competing source, especially on any topic where “current” matters (pricing, feature comparisons, tool roundups). Revisit and update dates honestly, and don’t just bump the timestamp without changing the content, which is its own credibility risk if a model or a human ever compares versions.

A Verification Checklist

Run through this in order. Each step depends on the one before it actually working:

1. Confirm OAI-SearchBot and PerplexityBot are explicitly allowed in robots.txt, not just “not explicitly blocked.”
2. If you run a WAF or bot-mitigation service, confirm their published IP ranges are whitelisted separately from the robots.txt rule.
3. Load your key pages with JavaScript disabled and confirm the core content is still present in the HTML.
4. Check that your most important pages each have one short, self-contained passage that directly answers the page’s core question, not just a well-written narrative that eventually gets there.
5. Validate Article, FAQPage, and Organization schema with a structured-data testing tool, not just by eyeballing the code.
6. Confirm dateModified is real and updates when you actually update content, not hardcoded to publish date forever.
7. Check Organization schema for consistency across every page: same name, same URL, same sameAs profile links, no drift between pages built at different times.

Common Mistakes

Blocking AI crawlers by default in a security-hardening pass. We’ve found this repeatedly: a well-intentioned security or performance audit blanket-blocks unfamiliar bot user-agents, catching OAI-SearchBot and PerplexityBot along with genuinely malicious scrapers. Audit your robots.txt and WAF rules specifically for these named agents; don’t assume a generic “block bots” rule leaves the ones you want untouched.

Treating schema as a citation guarantee. Valid schema removes ambiguity; it doesn’t force a citation. We’ve seen teams ship perfect Article and FAQPage markup on thin, generic content and conclude schema “doesn’t work” when the real gap was gate 3 (authority and content quality), not gates 1 or 2.

Optimizing for one engine only. ChatGPT’s search behavior and Perplexity’s citation behavior aren’t identical, and a fix aimed narrowly at one (say, ChatGPT’s browsing-triggered citations) can miss what actually drives Perplexity’s citation choices, which leans more heavily on its own always-on web index. Build for both crawlers and both retrieval patterns, not whichever platform you personally use most.

FAQ

Does blocking GPTBot hurt my chances of being cited by ChatGPT?

No. GPTBot is OpenAI’s training crawler, not its search-citation crawler. Blocking it opts your content out of model training but has no documented effect on whether ChatGPT cites your pages in search-grounded answers. That’s OAI-SearchBot’s job, and it needs to stay allowed separately.

Is llms.txt required to get cited by AI search engines?

No. It’s a real, well-specified proposal, but neither OpenAI nor Perplexity has confirmed their production crawlers use it as a ranking or citation input. Publish it if you want, since it’s low cost and does no harm, but the confirmed levers are crawler access, content structure, and structured data, not llms.txt.

Why would ChatGPT know about my brand but never cite my URL?

That’s usually a training-data mention, not a live citation: the model learned about you from data seen during training or from other sites’ coverage of you, but doesn’t consider your own site the best current source when it does a live, search-grounded lookup. Check whether OAI-SearchBot and PerplexityBot can actually reach and parse your pages, since that gap is the most common cause.

Does structured data actually matter if my WAF might be blocking the crawlers anyway?

Fix the crawler access first. Structured data only matters once a crawler has successfully reached and parsed the page. It’s gate 3 work, and it can’t compensate for a failure at gate 1. Check server logs or your WAF’s bot-traffic reports for OAI-SearchBot and PerplexityBot hits before investing further in schema.

How is this different from traditional technical SEO?

Substantial overlap: crawlability, clean HTML, structured data, and fresh content all matter for both. The differences: AI engines run their own distinct crawlers with their own robots.txt rules (not just Googlebot), they extract and cite individual passages rather than ranking whole pages, and they weigh entity consistency (Organization schema, consistent naming) more heavily as a trust signal than classic SEO does.

Every item on the checklist above is exactly what we check first in a GEO Audit: crawler access, passage structure, and schema validity, benchmarked against your named competitors, delivered in 5 business days for $997. If you’d rather see your specific gaps than infer them from a general checklist, that’s the fastest way to get there.

Ryan Brooks LinkedIn

Technical SEO Lead, MV3 Marketing

Ryan Brooks leads technical SEO at MV3 Marketing, specializing in schema architecture, entity graphs, crawlability, and the structural signals that determine whether AI answer engines cite a page.