How to Get Your Brand Into ChatGPT and Perplexity Answers – A Practical Guide

May 19, 2026 #AEO#GEO#ChatGPT#Perplexity#llms.txt#Structured Data

To get your brand to show up in ChatGPT and Perplexity answers, you need three things at once: content that answers a specific question in a citable paragraph; a clean technical foundation built on structured data, consistent entities, and open crawler access; and monitoring that tells you whether it’s working. There’s no button to press and nothing to book. You don’t get “displayed” – you get cited, and only when your page is the best, clearest source for exactly that question.

TL;DR

Write answer-first: state the answer in two to four sentences, then add context. AI systems cite passages, not whole pages.
Make yourself unambiguous as an entity: consistent NAP data, Organization schema, linked profiles, clean sameAs.
Let the right bots in: GPTBot, OAI-SearchBot, PerplexityBot. No crawler access, no citation.
llms.txt is nice to have, but it’s no silver bullet – content and crawlability come first.
Without monitoring, you’re flying blind. Query the models yourself, on a regular schedule.

Why “SEO is enough” doesn’t hold up here

Classic SEO optimizes for rankings – position 1 to 10 in a list of blue links. Answer Engine Optimization (AEO, sometimes also called GEO for Generative Engine Optimization) optimizes for something else: getting a language model to fold your content into its generated answer and, ideally, attribute it with a source. That’s a different game entirely.

The key difference: in a search results list, you compete for visibility. In an AI answer, you compete for citability. ChatGPT and Perplexity write their own answer and pull in passages that are clear, factual, and unambiguously attributable. A page that ranks well but buries its core statement in five nested paragraphs rarely gets cited. A page that answers the same question cleanly in the first paragraph stands a good chance – even if it sits at organic position four.

And yes, good SEO remains the foundation. Most of these systems are built on a web index (Perplexity has its own; OpenAI’s search relies in part on Bing infrastructure plus its own crawl). If you don’t exist in the classic index, you don’t exist for the AI either. AEO comes on top, not instead.

Step 1: Write to be cited, not just to be read

This is by far the biggest lever – and the one most people fail at, because it looks like work. Rightly so.

Answer-first structure. Start every important section with a self-contained, complete answer in two to four sentences. That passage has to make sense torn out of context, because that’s exactly how it gets processed. Don’t write “As mentioned above, this depends on several factors” – that’s worthless to a model. Write: “An online shop should auto-renew its SSL certificate every 90 days, for example via Let’s Encrypt. Manual renewal regularly leads to outages.”

One question, one H2. Phrase your headings as the questions people actually ask. “What does an Astro website cost?” beats “Our pricing models at a glance.” The models match the user’s question against your structure – make it easy for them.

Facts, numbers, definitions. AI answers love hard information: concrete figures, step-by-step lists, clear definitions, short comparison tables. Vague marketing prose (“we deliver tailor-made solutions for your success”) gets ignored. There’s nothing in it to cite.

Freshness and substance. Outdated content gets pulled in less often. A date, a visible “last updated” stamp, and real depth instead of a 400-word thin sheet all help measurably. What we see in practice: pages with a clear definition plus an example plus a take on the trade-offs get cited far more often than pure overview pages.

Step 2: Turn your brand into an unambiguous entity

A language model can only cite your brand if it understands it as a self-contained, consistent entity. If your company is “Müller & Partner GmbH” on your website, “Mueller und Partner” in your legal notice, “Müller Partner” on Google, and something else again on LinkedIn – your entity splits into four blurry fragments. None of them is trustworthy.

NAP consistency. Name, Address, Phone must be byte-for-byte identical everywhere: website, legal notice, Google Business Profile, industry directories, social profiles. It’s tedious and unspectacular. It’s still the foundation.

Organization schema with sameAs. Tell the machines explicitly who you are and where else you exist:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Rocket-Monkeys",
  "url": "https://rocket-monkeys.com",
  "logo": "https://rocket-monkeys.com/logo.png",
  "description": "Web development, AI integration, and AEO/SEO from Munich.",
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Munich",
    "addressCountry": "DE"
  },
  "sameAs": [
    "https://www.linkedin.com/company/rocket-monkeys",
    "https://github.com/rocket-monkeys"
  ]
}

The sameAs block is the node that ties your scattered profiles into a single entity. The more reliable, matching evidence a model finds for “this brand = this thing,” the more confidently it gets cited.

Mentions outside your own domain. Here’s where it gets uncomfortable: AI systems often weight what others say about you more heavily than what you say about yourself. Trade articles, industry directories, a well-maintained Wikipedia entry (where relevance warrants one), mentions in podcasts or guest posts – all of this shapes how the entity is understood. Pure self-PR on your own site isn’t enough.

Step 3: Use structured data the right way

Schema.org markup turns “text a human has to interpret” into machine-readable facts. That reduces uncertainty for the model – and uncertainty is the main reason a source doesn’t get cited.

The types that matter most in practice:

FAQPage for genuine question-and-answer blocks. Each question becomes a cleanly bounded, citable unit.
Article / BlogPosting with author, datePublished, dateModified. Authorship and freshness are trust signals.
Product, Service, Offer for specific services and prices.
BreadcrumbList for a traceable page hierarchy.

A common misconception: that schema is a “ranking trick.” It isn’t. It doesn’t guarantee a citation. It reduces the ambiguity of your content – nothing more, but that’s worth a lot. Use JSON-LD in the <head>, validate it with Schema.org’s Schema Markup Validator and the Rich Results Test, and only mark up what’s actually visible on the page. Made-up markup gets caught sooner or later.

Step 4: Let the right crawlers in

The dumbest avoidable mistake: you do everything right but block the bots. No crawler access, no citation – full stop. And there’s a nuance many people miss: training crawling and search crawling can be controlled separately.

OpenAI runs three bots, each individually controllable via robots.txt:

User agent	Purpose	Relevant for visibility?
`GPTBot`	Collects content for model training	Optional – affects training data
`OAI-SearchBot`	Feeds web search in ChatGPT	Yes, definitely allow
`ChatGPT-User`	Fetches pages when a user actively opens a link	Yes

For Perplexity:

PerplexityBot – builds the search index; definitely allow it.
Perplexity-User – fetches pages for specific user queries.

The key point: you can allow OAI-SearchBot and block GPTBot. That puts you in ChatGPT search without necessarily being used for foundation-model training. It’s the clean default for anyone who’s skeptical about training use but wants visibility. A pragmatic robots.txt:

User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Perplexity-User
Allow: /

User-agent: GPTBot
Disallow: /

Two honest caveats. First: changes to robots.txt don’t take effect immediately – with OpenAI it can take around 24 hours for the systems to catch up. Second: bot compliance isn’t perfect. Perplexity has repeatedly drawn criticism for deploying undeclared crawlers to circumvent no-crawl directives; Cloudflare temporarily removed it from its list of verified bots. If you run an aggressive WAF or bot protection, check that it isn’t accidentally blocking the legitimate AI search crawlers. We see this in audits more often than we’d like.

Step 5: llms.txt – useful, but no silver bullet

llms.txt is a convention proposed by Jeremy Howard in 2024: a Markdown file in the root directory (/llms.txt) that gives AI systems a curated map of your most important content. Unlike robots.txt, it blocks nothing – it curates. The idea: less noise, a clearer path to your core content.

A lean version:

# Rocket-Monkeys

> Web development, AI integration, and AEO/SEO from Munich.

## Services
- [Web Development](https://rocket-monkeys.com/web-development): Astro, performance, accessibility.
- [AI Integration](https://rocket-monkeys.com/ai): RAG, agents, automation.
- [AEO & SEO](https://rocket-monkeys.com/aeo): visibility in AI answers.

## Resources
- [Blog](https://rocket-monkeys.com/blog)
- [Contact](https://rocket-monkeys.com/contact)

An honest take – and here we deliberately part ways with the hype: as of 2026, llms.txt is a community convention, not an official standard, and not an IETF RFC. Support across the major providers is partial at best, and adoption sits roughly in the single to low double-digit percentage range of websites. In concrete terms: create the file, it takes half an hour and never hurts. But don’t expect a visibility jump from it. Anyone pouring their energy into a perfect llms.txt instead of citable content is optimizing the wrong variable.

Step 6: Measure whether it works

Without monitoring, you’re in the dark. The uncomfortable truth: AI answers are non-deterministic. The same question gives a different answer today than tomorrow, depending on model version, context, and chance. A single sample tells you almost nothing.

What we do in practice:

Define a prompt set. Pin down 20 to 50 real questions where your brand should show up – including the uncomfortable ones (“best Astro agency in Munich,” “alternatives to vendor X”).
Query regularly. Run the same prompts weekly in ChatGPT (with search) and Perplexity. Document it: Are you named? Linked? Represented correctly? Or is a competitor cited instead?
Analyze your server logs. Filter for hits from OAI-SearchBot, PerplexityBot, and the like. Are they crawling your pages at all? Which ones? That’s your direct feedback on whether the technical foundation is holding.
Use specialized tools. There are now dedicated AI-visibility tools that automate this. You don’t strictly need them at the start – a spreadsheet plus discipline gets you surprisingly far.

What matters is the half-life of any finding: what gets cited this week can look different after the next model update. AEO isn’t a project with an end date; it’s an ongoing process. Anyone selling it as a one-off measure hasn’t understood it.

Where we’d start

If you’re starting today, don’t start with llms.txt. Start with content: take your five most important pages and rewrite each one so the core question is answered in the first paragraph. In parallel, spend an hour checking your robots.txt and your Organization schema – two technical quick wins that often move the needle right away. Then build out the monitoring so you’re not guessing. The rest – FAQ schema, entity upkeep, external mentions – follows iteratively.

At Rocket-Monkeys, we build exactly this chain: technically clean Astro sites, AI used where it makes sense, and content that machines and humans both understand. If you want to know why your brand currently isn’t showing up in ChatGPT and Perplexity (or is showing up wrong), let’s look at your logs, your schema, and your most important pages together. Email us at info@rocket-monkeys.com for a no-obligation first conversation – we’ll tell you honestly where the biggest lever is.