What Can an Answer Engine Actually Quote From Your Page?
Only what is present, self-contained and legible in the HTML the server sends before any JavaScript runs. An answer engine lifts a passage it can use without the surrounding page, so a quotable passage has four properties: it answers the question in its first sentence, it repeats the subject instead of relying on "it" or "this", it carries its own qualifiers so it is still true when pulled out, and it sits in server-rendered text rather than inside an image, behind a tab, under an accordion or assembled by client-side script. You can test all four by hand in about ten minutes with two commands and no tools. Fetch the page with curl and no JavaScript, strip the tags, and read what is left: if your answer is not in that text, no model can quote it. Then run the question itself through ChatGPT, Claude, Perplexity, Gemini and Grok without your brand name in the query, and record which URL each one cited. The gap between what your HTML contains and what the engines actually quoted is the work.
An answer engine can quote exactly one thing from your page: a passage that is present in the HTML the server sends before any JavaScript runs, and that stays true when it is pulled out of the page around it. Everything else on the page is invisible to it. This article gives you the test, by hand, with the commands. It takes about ten minutes per page, needs no paid tool, and it is the same check we run at the start of a GEO audit before recommending anything.
What Makes a Passage Quotable
A quotable passage is a span of text that answers a question completely on its own, survives being separated from the page it sits on, and exists in server-rendered HTML rather than in an image, a tab, an accordion, or client-side script output.
An answer engine does not read your page the way a person does. It retrieves candidate passages, decides which one answers the question with the least ambiguity, and reproduces it with a link. Nothing about that process rewards a well-structured page whose answer is distributed across six paragraphs.
Four properties decide whether a passage can be used. All four have to hold. Three out of four is a pass in a content review and a fail here.
- 1.It answers in the first sentence. Not after context, not after a definition of the industry, not after your credentials.
- 2.It repeats the subject instead of leaning on "it", "this" or "the above". Pronouns break the moment the passage is lifted.
- 3.It carries its own qualifiers, so it is still accurate outside the page. A sentence that is only true because of a caveat two paragraphs up becomes a false claim when quoted.
- 4.It is in the server-rendered HTML. If a crawler fetch does not contain the words, no engine can quote them, however good they look in a browser.
The fourth property is the one that fails silently. The page looks right in every browser, every screenshot and every review, because the browser runs the JavaScript that assembles it. A crawler fetch does not.
The Fetch Test: What a Crawler Actually Receives
Start here, because it invalidates everything downstream if it fails. These commands run in any terminal on macOS or Linux, and in WSL on Windows. Replace the URL with your own page.
First, the response itself: every redirect hop, the final status, and any header-level noindex that overrides whatever the page says about itself.
- curl -sIL https://example.com/your-page
- Look for: a single hop to 200, not a chain. And look for x-robots-tag: noindex, which wins over any on-page robots meta and is invisible in the browser.
Save what the server sent
Fetch the page with no JavaScript engine involved, which is the closest simple approximation of what most crawlers receive on first contact.
- curl -s https://example.com/your-page > raw.html
- wc -c raw.html
A byte count in the low thousands on a page that looks content-rich in the browser is the tell. The shell arrived and the content did not.
Read the text a model would see
Strip the tags and read what is left. This is the crude version and it is enough: script and style contents survive it, so ignore any block of code you see, and read the prose.
- sed -e 's/<[^>]*>//g' raw.html | grep -v '^[[:space:]]*$' | head -60
- Then ask one question of the output: is my answer in there, in the first few lines of prose? If it is not, no engine can quote it.
Check the structure that helps it choose
What good looks like: exactly one H1 that states the question, H2s that are themselves questions phrased as a person would ask them, at least one JSON-LD block, and either a 200 or an honest 404 on llms.txt so you know whether it exists.
- grep -o '<title>[^<]*' raw.html
- grep -c '<h1' raw.html
- grep -o '<h2[^>]*>[^<]*' raw.html
- grep -c 'application/ld+json' raw.html
- curl -s -o /dev/null -w '%{http_code}\n' https://example.com/llms.txt
Reading What Came Back
The five results below cover most of what this test turns up. Each one has a different fix, and three of them are invisible in a browser.
| What you see | What it means | The fix |
|---|---|---|
| Byte count small, no prose in the stripped text | The page is assembled client-side. A crawler receives a shell. | Server-render or statically generate the page content. This is the highest-value fix on this list. |
| x-robots-tag: noindex in the headers | A server-level noindex that overrides the on-page meta tag. | Confirm it is intentional. If not, remove it at the edge or origin, whichever set it. |
| Two or more redirect hops before 200 | A redirect chain. Every hop is a chance to lose the request. | Compress to a single hop from the original URL to the final one. |
| More than one H1, or an H1 that is a slogan | No clear statement of what the page settles. | One H1, phrased as the question the page answers. |
| Zero application/ld+json blocks | No structured data, so extraction is inference only. | Add Article or FAQPage at minimum. The question in the schema should match the question in the heading, verbatim. |
Run these commands again after the fix. If the same command returns a different result, the fix landed. If it returns the same result, it did not, whatever the deploy log says.
The Four Properties, in Detail
With the fetch clean, the remaining work is the writing. Take your opening paragraph and apply this test: copy it into a blank document, with no title and no context, and read it. If a stranger could not tell what question it answers, an engine cannot either.
- Answer first. Move the answer to sentence one and let the context follow it. The instinct to earn the answer with background is a human-reader instinct, and it costs the citation.
- Name the subject every time. "The tag is 155 characters" survives extraction. "It should be about that long" does not.
- Fold the qualifier in. If the claim only holds for e-commerce sites, the sentence says e-commerce sites. A qualifier sitting in the paragraph above is lost on lift.
- Match the question. If people ask "how long should a meta description be", the heading is that question, not "Meta Description Length Guidelines". Verbatim phrasing is what gets matched.
- One fact per sentence. Two facts joined by a comma are harder to extract cleanly than two sentences, and the engine will often take only the first half.
The self-containment test, in one line: if the passage needs the paragraph above it to be true or to be understood, it is not quotable yet.
The Manual Citation Grid
The citation grid is a manual test in which the same set of non-branded queries is run through every major answer engine and the result is tabulated as queries by engines, recording whether the brand was cited, which URL was cited, and whether a competitor was cited instead.
This cannot be automated, because the platforms' terms do not permit scripted access, and it is the single most informative part of a GEO audit. It takes ten to fifteen minutes and it produces ground truth rather than a proxy metric.
Build the query list first. Never use your brand name: that is a navigational query and it tells you nothing about whether you are the answer. Use the questions a buyer asks before they know who you are.
- 1.Write five to ten category and intent queries. Patterns that work: "best X for Y", "how to do X without Z", "X versus Y", "what does X cost", "alternative to [a competitor]".
- 2.Run each one in ChatGPT, Claude, Perplexity, Gemini and Grok. Use a fresh session each time so prior context does not contaminate the answer.
- 3.For each cell record four things: was the brand cited, was a competitor cited, which exact URL was linked, and was the mention positive, neutral or negative.
- 4.Save the grid with the date. Re-run it monthly against the same query list. The movement is the metric, not the snapshot.
Record the cited URL, not just whether you were cited. That column is where the rank and cite split shows up in your own data: the URL an engine picked is often not the page you were optimising.
Reading the Grid
Four patterns come out of a first grid, and each one points at a different layer of the problem.
| Pattern in the grid | What it means | What to do |
|---|---|---|
| Absent on a commercial query a competitor wins | A content gap. There is no page of yours that answers this question directly. | Build the page in a citable format: a comparison table, a definition, or a decision guide. |
| Cited, but with outdated or wrong information | Stale cached context. The engine is quoting an older version of you. | Refresh the canonical page and llms.txt, then re-test the same query in 30 days. |
| Cited, but always last in a list | An entity weight gap. You are in the pool but ranked low within it. | Strengthen entity signals: a complete sameAs chain, consistent naming everywhere, more real referring domains. |
| Never cited on any query, in any engine | A foundational visibility gap. | Stop content work. Check crawler access and indexation first, because nothing downstream can work until that is fixed. |
The Fix List, in Order
Ordered by what blocks what. Doing item four before item one is the most common way to spend a quarter and move nothing.
- 1.Fix anything the fetch test found. A page a crawler cannot read is not a content problem and cannot be written around.
- 2.Rewrite the opening passage of your top pages so it passes the self-containment test.
- 3.Make every H2 the question a person actually types, and mirror those questions in FAQPage schema, phrased identically.
- 4.Publish an llms.txt with your core answers and the canonical URL for each, so the engines have a clean source to prefer.
- 5.Run the citation grid, save it with the date, and re-run it monthly. Without a baseline you cannot tell a fix from noise.
Item four is the one people skip because it is unfamiliar. Our free llms.txt Generator writes a valid file from your sitemap, previews the markdown, and gives you the file ready to publish.
- An engine can only quote what is in the server-rendered HTML. Everything else on the page is invisible to it
- A quotable passage answers in the first sentence, names its subject, carries its own qualifiers, and needs no paragraph above it
- Run curl -sIL for the headers and redirect chain, then curl -s piped through a tag strip to read what a crawler receives
- A small byte count on a page that looks rich in the browser means the shell arrived and the content did not
- Make every H2 the question a person types, verbatim, and mirror it in FAQPage schema with identical wording
- The manual citation grid across five engines is the only ground truth available. Run it monthly against a fixed query list
- Record which URL was cited, not only whether you were cited. That column is where the rank and cite split appears in your own data
The commands in this article are the live-verification steps Elshorafa Co. runs at the start of a GEO audit, where the governing rule is that a finding without a command output behind it is a guess. The citation grid method, the query patterns and the four grid readings are the same ones used in client audits. No client result, score or citation count is published here, because none of this method's client-specific outputs are public.
