How to do AI search optimization (AEO/GEO)

What AI search optimization actually is

AI search optimization is the practice of structuring a page so AI answer engines can read it, quote it, and attribute the quote back to you. It is close kin to SEO, but the outcome it targets is different. SEO wants your link in a ranked list. AI search optimization wants your sentence inside a generated answer, with your name on it.

Two terms travel with this work, and they mean nearly the same thing:

• AEO — answer engine optimization — optimizing to be the source an engine quotes when it answers a question.
• GEO — generative engine optimization — the same goal, framed around generative systems specifically.

Treat them as one discipline. The fundamentals — clear structure, honest markup, a crawlable page — serve all of them, because they all come down to a machine reading your page and deciding whether it is a reliable source to cite.

The shift is from ranking to being quoted

For most of search's history, the goal was a position in a list. You earned a rank, a searcher scanned the links, and you competed for the click. AI answer engines change the shape of the result. The engine reads the sources, writes a single answer, and cites the pages it drew from. There is no list to climb — there is an answer to be part of.

This changes what winning means. A page can rank well and still never be quoted, because ranking rewards relevance to a query while quotation rewards being liftable — a clean, self-contained passage the engine can drop into its answer and attribute. The two overlap, but they are not the same target, and optimizing only for the first leaves the second to chance.

Three consequences follow, and the rest of this guide is built on them:

• The unit of value is the passage, not the page. An engine quotes sentences, so you write sentences that can stand alone.
• Attribution is the outcome. A quote without your name is a reader you will never meet; a quote with your name is the citation that sends the reader and builds the authority.
• You are competing to be corroborated, not just found. An engine prefers a claim it can confirm across sources. Being one clear voice among the trusted ones beats being the loudest single page.

Why JavaScript rendering is the first thing to check

Most AI crawlers do not execute JavaScript. This single fact governs everything else. If your content is injected into the page by client-side code after load, the crawler fetches the page, sees an empty shell, and moves on. The content you can see in your browser does not exist to the machine that decides whether to cite you.

The fix is to server-render or statically generate anything you want read. And the verification matters as much as the fix: check with a raw request, not browser DevTools. DevTools run JavaScript, so they show you the rendered result and hide the problem. A raw fetch shows you what the crawler actually receives. If the answer is not in that raw HTML, it is not on the page as far as AI search is concerned.

This is why AI search optimization begins with a fetch, not with keywords. Structure and schema are wasted effort on a page the crawler cannot read in the first place.

The three moves that make a page citable

Once the page renders server-side, three moves make it easy to quote and attribute. None of them is exotic; the discipline is in doing all three consistently.

Move	What it does	How a machine uses it
Answer-first structure	Puts the direct answer in the first sentence	Lets the engine lift a clean, self-contained quote
Schema markup	Labels the content's meaning in JSON-LD	Tells the engine what the page is and who wrote it
Clean crawl surface	Server rendering plus llms.txt	Lets the engine find and read the page at all

Answer-first structure

Lead every page, and every section, with the answer. State the claim in the first sentence, then support it. An engine assembling an answer looks for a passage it can lift whole; a paragraph that opens with throat-clearing and buries the point three sentences down is hard to quote cleanly, so it gets passed over for a source that is easier to excerpt.

The difference is concrete. A throat-clearing opener buries the answer:

There are a number of considerations to weigh before deciding how often to update your pricing page, and the right answer really depends on your particular situation.

The answer-first version leads with it:

Update your pricing page whenever your prices change, and review it once a quarter. The rest of this section explains why that cadence holds up.

An engine can lift the second opener whole and attribute it; the first gives it nothing clean to quote, so it moves on to a page that does.

Structure the headings the same way. Each heading should own a single question a buyer would actually ask, and the text beneath it should answer that one question completely. A page built as a set of clean question-and-answer blocks is one an engine can navigate and cite section by section.

Give each of those question-headings a direct answer in the first paragraph beneath it — two or three sentences, call it forty to sixty words, complete on its own before any elaboration. A reader who sees only that paragraph should still have the answer. An engine that lifts only that paragraph should still quote you correctly. The elaboration comes after, for the reader who stays.

Some formats extract more cleanly than prose, and using them is not a trick — it is the same clarity that helps a human skimmer, made legible to a machine that skims differently:

• Definitions. State what a term means in one sentence, in the shape X is Y. Engines reach for clean definitions constantly, and a page that owns the definition of a term owns the answer to "what is X."
• Tables. A comparison, or any set of parallel facts, belongs in a table. Rows and columns carry the relationships explicitly, so a machine does not have to infer them from paragraphs.
• Numbered lists. A process or a ranking written as a numbered list is already in the shape an engine wants to reproduce.

The test for all three: could the engine reproduce this passage, unchanged, and be correct? If yes, it is quotable. If it would have to paraphrase to make it clean, a competitor's cleaner version gets the citation.

Schema that matches the visible page

Schema markup is structured data — usually JSON-LD — that labels what your content means: this is an article, this is its author, these are the questions it answers. It turns prose a machine has to interpret into facts it can read directly.

The rule that keeps schema honest is simple: the markup must match the visible DOM. Emit FAQPage only when the questions and answers are actually on the page. Emit HowTo only when the steps are visible prose the reader can follow. Schema that describes content the page does not show is a mismatch an engine can detect, and it undermines the trust the markup was meant to build.

Here is the minimal shape, marking up the pricing-page question from earlier:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{ "@type": "Question", "name": "How often should you update your pricing page?",
    "acceptedAnswer": { "@type": "Answer", "text": "Whenever your prices change, and a review once a quarter." } }]
}

The answer text matches the sentence a reader sees on the page — the same rule, applied to the markup.

A clean crawl surface, including llms.txt

An llms.txt file is a plain-text index at your site root that points AI systems to your most important pages, each with a one-line description. It does not replace schema or good HTML — it complements them by making your best content easy to find and parse. It is inexpensive to add and to keep current, and it gives you a direct way to say these are the pages worth reading.

Let the right crawlers reach the page

A page the crawler cannot fetch cannot be cited, and each AI system fetches with its own named agent. If your robots.txt or a firewall blocks those agents, you have opted out of AI search without deciding to. Know the names, and decide on purpose.

The agents fall into two jobs, and the distinction matters:

Agent	Who runs it	What it is for
GPTBot	OpenAI	Crawling pages to train and inform models
OAI-SearchBot	OpenAI	Fetching pages to surface in ChatGPT search
ClaudeBot	Anthropic	Crawling pages for Claude
PerplexityBot	Perplexity	Fetching pages Perplexity can cite in answers

The search-and-cite agents — the ones that fetch a page in order to quote it in a live answer — are the ones you most want to allow, because blocking them removes you from the answer directly. Training crawlers are a separate policy choice: you can allow citation while forming your own view on training, and the two are controlled by different agent names.

Check three things:

1. robots.txt. Confirm you are not disallowing the agents you want to reach you. A broad rule aimed at scrapers can catch citation crawlers too.
2. The firewall and CDN. Bot-mitigation rules block by user-agent and can drop these crawlers before robots.txt is ever read. A page that returns a challenge to a crawler is, to that crawler, blank.
3. Rate limits. An aggressive limit can starve a crawler of the pages it came for. Let it read the ones that matter.

Access is the floor. It earns you nothing on its own — but without it, nothing else you do can be seen.

The classic SEO fundamentals still do the work

AI-search optimization sits on top of search-engine optimization; it does not replace it. A page an answer engine can cite is, first, a page a search engine can find, read, and trust — so the traditional groundwork is the foundation, not a legacy chore. A workable SEO pass runs in a few steps:

• Map keywords to pages, one intent per page. Give each page a small set of related terms it is meant to own; don't make one page chase five unrelated queries. Specific, long-tail queries are where a new site wins first — the competition is thinner and the intent is clearer.
• Get the on-page basics right. A descriptive title and H1 that name the topic, a clean keyword-bearing URL, a unique meta description, meaningful image alt text. None of it is clever; all of it is the difference between a page that gets read and one that gets skipped.
• Fix the technical layer. A sitemap and a sane robots file, single-hop redirects for anything you move, and internal links that connect related pages so a crawler can see the shape of what you know.
• Earn authority off the page. Citations, mentions, and links from places your buyer already trusts. This is slow and hard to fake, and it is what separates a page that ranks from one that merely exists.

Do this, and the citability moves above have something solid to stand on. Skip it, and you are optimizing for the AI answer while staying invisible to the search index the AI is often reading from in the first place.

How to think about what you want to be cited for

The part no tool decides for you is which claim your page should be the authority on. AI answer engines quote sources that are clear and specific, not sources that are broad and hedged. A page that tries to say something about everything gives an engine nothing sharp to attribute. A page that owns one claim — states it plainly, supports it with evidence, and structures it for extraction — is the one that gets cited.

So the strategic decision precedes the technical work. Choose the question you want to be the answer to. Then make your page the clearest, best-attributed source on that specific question, and let the structure, schema, and crawl surface carry it to the engines.

Attribution also depends on being a recognizable source, not just a readable page. An engine is more willing to cite an entity it can identify — a named organization with a consistent presence — than an anonymous page it cannot place. This is why site-wide Organization markup, a consistent author, and links to the same identity across the places you appear matter: they let a machine resolve "who is this" into a stable answer. The individual page earns the quote; the consistent identity earns the trust that makes the quote likely. Optimize both — the page for the specific claim, and the site for being a source an engine recognizes when it sees you again.

Become an entity, not just a page

An engine cites sources it can identify. The previous section put the page and the identity side by side; this is how the identity gets built. An entity is a thing a machine can resolve to a single, stable referent — this organization, this author, this product — rather than a name it sees once and cannot place. Entity recognition is the ground citation is built on, because an engine is far more willing to quote a source it can name than one it cannot.

Three signals build the entity, and they reinforce each other:

• A consistent identity. Use the same organization name, the same author names, and the same descriptions everywhere you appear. Contradictory identities — a different name here, a different bio there — give a machine nothing stable to resolve, so it resolves nothing.
• sameAs links. In your Organization and Person schema, list the other places the same entity exists: your profiles, your listings, the authoritative references that already name you. sameAs is the explicit statement these are all the same entity, and it lets a machine merge scattered mentions into one recognized thing.
• Corroboration by trusted third parties. The strongest signal is not one you emit — it is being named by sources the engine already trusts. When independent, reputable pages reference you as the authority on something, the engine has its confirmation. This is the AI-search equivalent of a reference: it is earned by being genuinely worth citing, and it cannot be manufactured with markup.

The order matters. Markup declares the entity; third-party citation confirms it. You control the declaration completely and the confirmation not at all — which is why the durable strategy is to be the source worth citing, and let the schema make you easy to recognize when someone does.

Measure whether you are quoted, not whether you rank

Rankings tell you little here. The measure that matters is whether an AI answer engine quotes you, and for which questions — so track that directly, qualitatively, and do not assume it.

The measurement is a habit, not a dashboard:

• Ask the engines your own questions. Take the questions you want to own and put them to the answer engines your buyers use. Read the answers. Are you quoted? Named? Linked? Or is a competitor the source?
• Note who gets cited instead. When you are not the source, the page that is tells you what the engine found more liftable, more authoritative, or more recognizable. That is a concrete edit list.
• Watch for your own sentences. When an engine reproduces a phrasing that is unmistakably yours, that is the outcome the whole practice aims at — your words, attributed, inside the answer.
• Re-check after every change. Citation shifts as you restructure, as engines update, and as competitors move. A single reading is a snapshot; the signal is the trend across readings.

Two cautions. First, answers are not deterministic — the same question can return different sources on different days, so read the pattern across several runs rather than trusting one. Second, resist inventing a score. A confident number laid over a soft signal is worse than an honest qualitative read, because it hides how much you are guessing. Record what you saw, when, and for which question. That log — not a metric — is the evidence that the work is working.

What the audit produces

The deliverable is a repeatable page audit + schema + llms.txt. The audit is a checklist you run against any URL: does it render without JavaScript, does it answer first, do the headings each own a question, does the schema match the visible text, and is the page listed in llms.txt. The schema is the JSON-LD you add. The llms.txt is the site-root index you maintain.

Written as a checklist, the practice scales past a single page. You optimize one URL by hand, capture what you did, and re-run it on the next — which is how a one-page win becomes a site-wide standard rather than a heroic effort nobody repeats.