FAQ Schema: Build & Validate FAQPage JSON-LD

FAQ schema isn’t dead, but it no longer does what most guides still claim. For years, the pitch was simple: add FAQ schema to a page, earn an expandable accordion under your listing, and watch your search result take up more vertical space. That payoff is gone. As of May 7, 2026, Google no longer shows FAQ rich results in Search for anyone — including the government and health sites it had kept eligible since 2023.

So why write a guide about it? Because FAQPage markup still earns its place in your structured data, just for different reasons than the old SERP screenshots promised. It clarifies entities for AI search, keeps your on-page Q&A machine-readable, and costs almost nothing to maintain once you understand the required properties. Below is the honest, current breakdown: what FAQ schema does today, what it no longer does, and how to write and validate a clean JSON-LD block.

What FAQ Schema (FAQPage) Does

FAQ schema is a piece of structured data that labels a list of questions and their answers so machines can read them. It uses the FAQPage type from the schema.org vocabulary, and Google recommends JSON-LD as the format. In practice, you drop a single <script type="application/ld+json"> block into the page, and the page text stays exactly as it was.

The markup describes a specific shape. A FAQPage holds a mainEntity array. Each item in that array is a Question with a name (the question text) and an acceptedAnswer. The acceptedAnswer is an Answer with a text property containing the full reply. That nesting — FAQPage → Question → acceptedAnswer → Answer — is the entire model, and it maps almost word-for-word onto how a normal FAQ section already reads.

Crucially, FAQ schema describes content that must already be visible content on the page. The markup is a label, not a place to stash extra text. We’ll come back to why that rule still bites people even now that the rich result is gone.

Do FAQ Rich Results Still Appear in Search?

No. This is the part most older articles get wrong, so it’s worth stating plainly. Google announced in August 2023 that FAQ rich results would only show for “well-known, authoritative government and health websites,” and it stripped them from everyone else. Then on May 7, 2026, Google removed FAQ rich results entirely — even those remaining gov and health sites lost them.

The cleanup keeps going on a published timeline. According to Google’s FAQPage documentation, the Rich Results Test and the Search Console rich-result report stop supporting FAQ in June 2026, and Search Console API support for the feature ends in August 2026. In other words, the entire reporting and testing apparatus around the FAQ rich result is being retired.

If you still see an old screenshot of an FAQ accordion in a SERP, treat it as a historical artifact. The feature that produced it has been switched off. Any guide that promises you that accordion today is describing a world that no longer exists.

Is FAQ Schema Still Worth Adding?

Often, yes — but for narrower, less flashy reasons. Once you stop expecting a rich result, three genuine benefits remain, and they line up neatly with where search is actually heading.

• AI and answer-engine citability. ChatGPT, Perplexity, Gemini, and Google’s AI Overviews extract clean question-and-answer pairs well. Explicit Question and Answer entities make your content easier to lift and attribute. We cover this shift in depth in our piece on AI search and structured data, and FAQ markup is one of the cheaper ways to support it.
• Entity clarity for Google. Even without a visual rich result, FAQ schema helps Google understand that a block of text is a discrete question and its answer. That can feed featured snippets and “People also ask” results, which draw from clearly structured Q&A content.
• Internal QA and consistency. Marking up questions forces you to write self-contained answers. Each acceptedAnswer has to stand on its own, which usually improves the on-page UX as a side effect.

What it won’t do is move rankings on its own or restore the old accordion. So add FAQ schema where you already have a real FAQ section worth machine-reading. Don’t bolt it onto pages just to chase a SERP feature that no longer ships.

Required FAQPage Properties

The spec is small, which is good news: there are only a handful of required property fields, and missing any one of them invalidates the block. Here’s the full set, matched to the schema.org Question and Answer definitions.

A few rules worth internalizing. First, every Question needs exactly one acceptedAnswer — the mainEntity array carries the multiple questions, not multiple answers per question. Second, the text field accepts a limited set of HTML tags (such as <a>, <p>, <ul>, <li>, <strong>, and the heading tags), so you can include a link or a short list inside an answer. Third, the question and answer text in your markup must match the visible content on the page.

Copy-Paste FAQ Schema JSON-LD Example

Here is a complete, valid FAQPage block in JSON-LD. Replace the questions and answers with your own, keep the structure, and paste it into the <head> or anywhere in the <body> of the page that contains the matching FAQ.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does setup take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Most accounts finish onboarding in under an hour. You connect your data source, confirm a few settings, and start tracking the same day."
      }
    },
    {
      "@type": "Question",
      "name": "Do you offer a free plan?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. The free tier covers up to 10,000 events per month with no time limit. You can upgrade whenever you need higher volume."
      }
    },
    {
      "@type": "Question",
      "name": "Can I export my data?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "You can export to CSV or JSON at any time from the dashboard. There is no lock-in and no export fee."
      }
    }
  ]
}
</script>

Notice the pattern. One FAQPage wraps a mainEntity array, each array item is a Question with a name, and each Question carries a single acceptedAnswer of @type Answer with the reply in text. Add or remove array items to match the questions on your page. If you’d rather not hand-write the block, a schema markup generator can produce the same structure from a plain list of questions — but you’ll still want to read the next section, because generators happily emit markup that breaks Google’s rules.

Common FAQ Schema Mistakes (and Fixes)

The syntax is forgiving; the policy rules are not. These two mistakes account for most of the broken FAQ markup we see, and both predate the rich-result removal — they still cause validation warnings and undermine the AI-citability benefit.

Hidden or accordion content that isn’t visible on-page

Google’s long-standing rule is that FAQ markup must describe visible content. An accordion that’s collapsed by default is usually fine, because the answer is present in the page’s HTML and a user can expand it. The problem starts when the answer is loaded only on click via JavaScript, or hidden with display:none and never shown. In that case, the rendered page doesn’t contain the text your markup claims, which is a mismatch.

The fix is straightforward: make sure every answer in your JSON-LD exists as real text in the page’s rendered HTML. A simple test is to load the page with JavaScript disabled, or view the rendered source, and confirm the answer text is there. If it isn’t, move the content into the static markup before you mark it up.

Marking up Q&A that users can’t see

A related and worse version: adding FAQ schema for questions and answers that don’t appear on the page at all. Some teams build an invisible FAQ block purely to feed structured data, hoping for an SEO edge. That violates Google’s structured-data guidelines on hidden content and offers no real benefit now that the rich result is gone.

Treat the markup as a mirror of the page. If a question and answer are worth labeling for machines, they’re worth showing to people. When in doubt, write the FAQ section first as ordinary visible content, then generate the matching FAQPage block from what’s actually there.

Generate, Then Validate Your FAQ Schema

The reliable workflow is two steps: build the block, then check it against both schema.org and Google. Here’s the process we run on every page that gets FAQ schema.

1. Write the visible FAQ first. Put the real questions and answers on the page as normal content. This guarantees the markup will match what users see.
2. Generate the JSON-LD. Hand-write the block from the example above, or use a schema markup generator to convert your question list into a valid FAQPage structure. Either way, confirm every Question has a name and an acceptedAnswer.
3. Validate the syntax and vocabulary. Paste the block into our free FAQ schema checker to confirm structure and required properties in one pass. Then cross-check against the schema.org validator for vocabulary errors. Our guide on how to validate structured data step by step explains how to read the output from each tool.
4. Confirm what Google sees. Until support sunsets in mid-2026, the Rich Results Test still parses FAQPage and reports structural errors, even though it no longer promises a SERP feature. After that, lean on the Schema Markup Validator and your own rendered-HTML checks.

If you want the longer history of how this kind of structured data validation came to work the way it does — from rigid XML grammars to today’s JSON-LD — our background piece on how schema validation evolved connects the dots. The short version for FAQs: write the answers for humans, mark them up faithfully, validate against both schema.org and Google, and judge success by entity clarity and AI citability rather than a SERP accordion that no longer exists.

Frequently Asked Questions

What is FAQ schema (FAQPage) and how does it work?
FAQ schema is structured data that uses the FAQPage type from schema.org to label a list of questions and answers. You add a JSON-LD block where a FAQPage contains a mainEntity array of Question items, and each Question has a name and an acceptedAnswer holding the reply. Machines read it to understand which text is a question and which is its answer.

Do FAQ rich results still show in Google search?
No. Google restricted FAQ rich results to authoritative government and health sites in 2023, then removed them for everyone on May 7, 2026. No site type currently earns the FAQ accordion in Search, and the related Rich Results Test and Search Console reporting are being retired through mid-2026.

Which sites are still eligible for FAQ rich results?
None, as of the May 2026 change. The earlier government-and-health carve-out has been removed too, so no category of site shows FAQ rich results in Google Search anymore. FAQPage markup is still valid structured data — it just doesn’t produce that visual rich result.

Is it still worth adding FAQ schema if rich results are restricted?
Often yes, for entity clarity, AI and answer-engine citability, and cleaner on-page Q&A — not for a SERP feature. It’s low-cost to maintain when you already have a real FAQ section. Skip it on pages without genuine visible content to mark up.

What are the required properties for FAQPage markup?
At the root you need @type: "FAQPage" and a mainEntity array. Each item needs @type: "Question", a name, and an acceptedAnswer. That acceptedAnswer needs @type: "Answer" and a text property. Miss any required property and the block is invalid.

How do I generate and validate FAQ schema correctly?
Write the visible FAQ first, then build the JSON-LD by hand or with a schema markup generator, making sure each Question has a name and an acceptedAnswer. Then validate the block in the schema.org validator for syntax and required fields, and confirm the answer text matches the page’s visible content.