Structured Data for AI: The Schema.org Markup Answer Engines Read

JSON-LD in 30 seconds

JSON-LD is structured data written as JSON and placed in a <script type="application/ld+json"> tag in your page's head or body. It is a machine-readable fact layer sitting on top of your visible content: this is an article, written by this author, published on this date, answering these questions, selling this product at this price. Unlike microdata, it requires no changes to your HTML elements — one self-contained block describes the whole page.

Search engines have parsed this layer for over a decade to build rich results. Answer engines read it alongside your visible text to establish what a page is, who wrote it and what it answers, without guessing from prose alone.

What AI engines actually do with it

Honest positioning first: no AI engine has published documentation confirming exactly how its models consume schema.org markup, and anyone claiming "ChatGPT requires FAQPage schema" is speculating.

What we do know is that structured data solves two problems language models are genuinely bad at: disambiguation and entity alignment. Is "Mercury" the planet, the element or the defunct car brand? Is the "J. Smith" who authored this page the same person quoted elsewhere? A machine-readable block stating "this is an Article, written by this Person, published by this Organization, on this date" removes the guesswork. Structured facts are cheap for an extraction pipeline to pull, reliable to store and easy to attribute — all of which help your page get cited correctly instead of paraphrased into mush.

The effort is also not speculative: the same markup drives Google rich results today. FAQ rich results, HowTo steps, breadcrumbs and product stars are all schema-powered. You build one layer that pays off in classic search immediately and positions you for answer engines as their pipelines mature.

The types worth your time

Type	What it tells the machine
Article	This is editorial content, with a headline, named author and dates attached.
FAQPage	These question-and-answer pairs are complete, standalone answers.
HowTo	This is a step-by-step task with an ordered sequence and required tools.
Organization	This is who operates the site: legal name, logo and sameAs profiles.
Person	This named author is a real entity with a role and a profile elsewhere.
Product	This is a thing you sell, with price, availability and reviews.
BreadcrumbList	This is where the page sits in the site hierarchy.

If you add only one, add FAQPage. It maps directly onto how answer engines assemble answers, and it only works when the page already contains real question-and-answer content — which is exactly the approach described in the content structure guide.

A complete FAQPage example

This is valid JSON-LD you can adapt and paste into any page that visibly contains the same question-and-answer text:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Can I allow ChatGPT search but block AI training?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. GPTBot handles training and OAI-SearchBot handles search. Allow OAI-SearchBot in robots.txt while disallowing GPTBot, and the two policies stay independent."
      }
    },
    {
      "@type": "Question",
      "name": "How long does a robots.txt change take to apply?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Crawlers re-read robots.txt on every fetch cycle, so policy changes usually take effect within days rather than months."
      }
    }
  ]
}
</script>

Notice what makes it valid: @context declares the vocabulary, every question matches visible text on the page, and each answer is complete on its own. Generate this block automatically with the free Schema generator instead of hand-writing JSON and hoping for the best.

Validate before you ship

Two free checkers cover everything. The Google Rich Results Test fetches a live URL and reports which rich result types the page qualifies for. The Schema.org validator parses raw JSON-LD and flags syntax and nesting errors against the vocabulary itself. Run both: one checks eligibility for Google features, the other checks that your markup is technically clean. A block that fails validation is ignored entirely — parsers do not partially repair broken JSON.

Common mistakes

• JSON syntax errors. A trailing comma or one missing closing brace invalidates the entire block. This is the number one failure the validators catch.
• Markup for invisible content. Marking up question-and-answer pairs that do not appear on the page violates Google's guidelines and reads as manipulation to any pipeline comparing markup against visible text.
• FAQ stuffing. Twenty loosely related questions on a product page dilute the signal. Four to eight genuine questions beat a padded list every time.
• Missing @context. Without the "https://schema.org" context line, your keys are undefined strings rather than schema terms. The block still parses as JSON, but it means nothing.

Where to go next

Schema is one of several machine-first files a site should maintain — see how llms.txt complements it, and how both fit into the full workflow in the GEO overview. If you are targeting one engine specifically, the ChatGPT optimization guide covers what ChatGPT's crawlers and answer pipeline reward.