Aizii Learn · AI Search

[← Back to Learn](https://aizii.ai/learn)

# How to add FAQ schema for AI overviews

FAQ schema is a block of JSON-LD on a page that labels your questions and answers in a machine-readable form, using the FAQPage type from schema.org. It tells a machine, in a format it can parse without guessing, that this page holds a question, and this text is its answer. It does not change what visitors see. It gives the same questions and answers a second, structured form that extraction systems can lift directly.

One correction first, because the old advice is out of date. Google has removed the FAQ rich result feature from Search, and it has removed the FAQ rich result documentation. Do not add FAQ schema expecting a dropdown rich result in Google. That visual result is gone. What remains is the schema itself, which is still valid schema.org markup, and the question-and-answer shape, which is still the shape AI systems extract most easily. Add it for extraction, not for a rich result.

Google says the same thing from the other direction in its guide to generative AI features: structured data is not required for generative AI search, and there is no special schema markup you need to add to appear in AI Overviews or AI Mode. So FAQ schema is not a requirement and not a guarantee. It is a clarity aid. It makes the answers on a page you already wrote easier for a machine to find, match to a question, and quote.

## What the markup actually is

Schema.org defines FAQPage as a WebPage presenting one or more frequently asked questions. A FAQPage block holds a list of Question items, and each Question holds the full question text and one accepted answer. The required shape is small: a FAQPage with a mainEntity array, each entry typed as Question, with a name holding the question and an acceptedAnswer typed as Answer holding the answer text.

The block goes on the page that shows the questions and answers, as a script tag in the head or the body. It has to be in the initial HTML the server sends, not injected by a script after the page loads, because many AI crawlers do not run JavaScript. And the markup must match the visible page. Every question and every answer in the block has to appear in the text a visitor can read. Marking up answers that are hidden, or that do not exist on the page, breaks the general structured data guidelines Google publishes, and it gives an extraction system a fact it cannot check.

Use FAQPage only where a page has questions with one answer each, written by the site itself. If a page has one question and visitors can submit their own alternative answers, schema.org has a different type for that, QAPage. Do not use FAQPage for advertising copy dressed up as questions. A question that is really a sales pitch, with an answer that is really a promotion, is not an FAQ.

## The complete FAQPage block

Here is a full JSON-LD block for a camping gear store, with two questions. In the example, \[yourdomain.com\] is a placeholder, replacing yourdomain.com with your actual domain. Every field maps to a schema.org FAQPage, Question, or Answer property.

```
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is your return window for tents?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "You can return an unused tent within 60 days of delivery for a full refund. The tent must be clean, dry, and in its original stuff sack."
      }
    },
    {
      "@type": "Question",
      "name": "Do you ship to PO boxes?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "We ship small items to PO boxes, but tents and other oversized items ship to a street address only, because our carriers will not deliver them to a PO box."
      }
    }
  ]
}
</script>
```

Field by field:

-   **@type FAQPage**: one per page. A page holds a single FAQPage block that lists all of its questions. Do not add a separate FAQPage block per question.
-   **mainEntity**: the array of Question items the page answers. You must include at least one valid Question item.
-   **Question name**: the entire text of the question, exactly as it appears on the page. Do not shorten it in the markup and keep the long version on the page.
-   **acceptedAnswer text**: the entire text of the answer, exactly as it appears on the page. There is one answer per question in this shape.
-   **@context**: always the schema.org address. It tells any reader which vocabulary the types come from.

If the page already carries other JSON-LD, such as Product or Organization markup, keep the FAQPage block separate and do not merge the two types into one block. A page can hold more than one script tag of this kind, and each one should describe only its own thing.

## Rules that decide whether it works

**Match the visible page, word for word.** The question in the markup and the question on the page should be identical, and the same for the answer. When they drift apart, an extraction system has two competing versions of the same answer and may trust neither.

**One answer per question.** FAQPage is built for a single accepted answer. If your page genuinely offers several competing answers to one question, that page is not a FAQPage. Rewrite it so each question has one answer, or leave the markup off.

**Write answers that stand alone.** An answer that only makes sense after reading three paragraphs above it cannot be lifted cleanly. Each answer should restate the subject in its first sentence and resolve the question in two to four sentences. For the writing side of this, see our guide to writing FAQ pages for AI overviews.

**Keep it to the questions the page actually answers.** A page with a short, focused set of real questions is easier to extract from than a page stuffed with dozens of near-identical questions. Add a question only when the page genuinely answers it.

**Do not mark up content visitors cannot see.** If an answer sits behind a login, or only appears after a click that a crawler cannot perform, leave it out of the block. The markup describes the visible page, not the page you wish a crawler could reach.

## Validate before you ship

Two free tools, no signup, and they check different things:

1.  Google's Rich Results Test: paste a page URL and it shows which structured data Google detects on it, with errors and warnings per field. Note that FAQPage no longer produces a rich result in Google, so the test may show little or nothing for this type. That is expected now, not a sign your markup is broken.
2.  The Schema Markup Validator: checks the JSON-LD against the schema.org vocabulary itself. This is the tool that matters most for FAQPage now, because it catches typos in property names and wrong types that the Google tool will not flag.

Run the validator on the page, fix every error it reports, and then compare the markup against the visible page by eye. The validator cannot tell you the answer text drifted from the page. Only a side-by-side read can.

## Common mistakes

**Expecting a rich result.** The most common mistake now is adding FAQPage for a visual result Google no longer shows. Judge the markup on extraction, not on a dropdown in search results.

**Markup that does not match the page.** The block says one thing and the page says another, often because the page copy was edited and the JSON-LD was not. Generate the block from the same content that renders the page, or update both together every time.

**Two conflicting FAQ blocks.** Usually one from a theme and one from an SEO app, with different questions or different answers. Audit the page source for every script tag of type application/ld+json before adding your own.

**Advertising as questions.** "Why is our tent the best tent?" with an answer that is a sales pitch is not an FAQ. It reads as promotion to a human and to a machine, and it wastes the clearest extraction slot on the page.

**Marking up a page with no visible FAQ.** A FAQPage block on a page that shows no questions and answers is markup with no page behind it. Add the visible questions first, then the block.

## Adding it on your platform

The markup is the same everywhere. Where you put it depends on your platform, and that is a general instruction, not a verified click path: check whether your theme or SEO app already emits a FAQPage block, and check the vendor docs linked in Sources for the current path before relying on a menu name in this guide. If a block already exists, fix that block instead of adding a second one. If your platform has no built-in FAQ schema, add the script tag to the page template for your FAQ page, or use a schema app that lets you paste JSON-LD per page.

## What this guide does not cover

This guide covers the markup. It does not cover writing the questions and answers themselves, which is the guide to writing FAQ pages for AI overviews, and it does not cover getting crawlers to your pages in the first place, or keeping the answers accurate as your policies change, which is monitoring work. Markup makes answers extractable. It does not write good answers, and it does not promise they will be cited.

## Check your own brand now

Run the free scan. It takes seconds, no signup, and shows whether AI crawlers can read your brand today: aizii.ai/aeo-scan

[Run the free scan](https://aizii.ai/aeo-audit)

## Sources

-   Schema.org, FAQPage type (specific): [https://schema.org/FAQPage](https://schema.org/FAQPage)
-   Schema.org, Question type (specific): [https://schema.org/Question](https://schema.org/Question)
-   Google Search Central, Optimizing your website for generative AI features on Google Search (specific): [https://developers.google.com/search/docs/fundamentals/ai-optimization-guide](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)
-   Google Rich Results Test (general docs): [https://search.google.com/test/rich-results](https://search.google.com/test/rich-results)
-   Schema Markup Validator (general docs): [https://validator.schema.org/](https://validator.schema.org/)

Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
