FAQ Schema Markup: Complete Guide with Examples

FAQ schema is the single highest-leverage structured data you can add to a content site in 2026. It's cheap to implement, works across every AI search engine, and disproportionately increases citation rates in generative answers. It's also one of the most misunderstood schema types — partly because Google deprecated FAQ rich results in 2023, which many people took to mean "FAQ schema doesn't matter anymore." That reading is wrong.

This guide is the complete version: what FAQ schema is, why it's more valuable in 2026 than ever, how to structure it correctly, and how to implement it without breaking your site.

What is FAQ schema markup?

FAQ schema is a structured data format — defined by Schema.org — that annotates question-and-answer content on your page in a machine-readable way. Instead of a crawler trying to figure out from your HTML which text is a question and which text is its answer, FAQ schema tells it explicitly.

The format looks like this:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is schema markup?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup is a structured data vocabulary you add to your HTML…"
      }
    },
    {
      "@type": "Question",
      "name": "Does Google still show FAQ rich results?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google reduced FAQ rich results in traditional search in 2023…"
      }
    }
  ]
}
</script>

Three nested types. FAQPage is the container; Question is each question you're answering; Answer (wrapped in acceptedAnswer) is the authoritative response. The mainEntity array lets a single FAQPage contain any number of Q&A pairs.

Our FAQ schema generator produces this output from a simple form — no JSON editing required.

The 2023 deprecation: what actually changed

In August 2023, Google announced that FAQ rich results (the expandable "People Also Ask" style accordion under search results) would be limited on desktop and restricted on mobile to official government and health sites. This triggered a wave of articles declaring FAQ schema dead.

Here's what actually happened: one narrow Google surface got restricted. The underlying FAQ schema spec is still valid, still parsed, and still weighted by every other consumer of structured data — including the consumers that matter most in 2026.

Specifically:

• ChatGPT with browsing reads FAQ schema and cites FAQ-structured pages disproportionately.
• Perplexity uses FAQ schema as a primary source-ranking signal.
• Google AI Overviews pulls from FAQ-marked pages more aggressively than the same content without schema.
• Voice assistants (Alexa, Google Assistant, Siri) use FAQ schema for direct answer matching.
• Bing and Bing Chat continue to weight FAQ schema positively.

The result: FAQ schema is actually more valuable in 2026 than it was in 2022, because it routes citation traffic through AI surfaces that didn't exist or were nascent three years ago. Our guide on how to get cited by ChatGPT breaks down the broader mechanics; FAQ schema is the single highest-leverage action in that guide.

Why FAQ schema works so well for AI search

AI search engines are trained on massive corpora of question-answer pairs. Forum posts, Stack Overflow answers, Reddit threads, help desk articles, and academic Q&A databases all share one property: they're explicitly structured as questions paired with answers. Large language models learn to pattern-match this structure deeply.

When your page declares itself as a FAQPage via schema, you're handing the model an entry point in the exact format it's been trained to trust. The model doesn't have to parse your prose, identify the question, map it to the answer, and reconstruct the pairing — you've done that work for it. It can extract the exact question text and the exact answer text as atomic units.

The downstream effect: when a user asks the AI a question that semantically matches one of your marked-up questions, your answer is a near-automatic candidate for citation. The AI quotes or paraphrases your Answer.text and attributes the page.

What makes a good FAQ schema implementation

Not all FAQ schema is equally effective. Here are the patterns that correlate with citation in our analysis of AI-cited content:

Write questions users actually ask

The single biggest mistake is writing questions that sound like SEO keyword variations rather than real user language. "FAQ schema meaning" is a keyword phrase. "What is FAQ schema?" is a question. AI engines pattern-match on natural language questions — the ones that include the full interrogative form, end in a question mark, and read aloud naturally.

Good: "Does FAQ schema still work in 2026?" Bad: "FAQ schema 2026 status"

Keep answers self-contained

Every answer should make complete sense if quoted in isolation. AI engines often extract just the answer, without the question or surrounding context. If your answer begins with "As mentioned above…" or "Following the previous example…", it doesn't work in isolation.

Lead each answer with the direct response. Use specific entity names rather than pronouns. Include dates and numbers that make the answer stand on its own.

Target 80–200 words per answer

Answers under 50 words lack the substance AI engines prefer to cite. They also trigger "answer is too short" warnings in Google's Rich Results Test. Answers over 250 words dilute the signal and become less quote-worthy. The 80–200 word range is the sweet spot: enough to be authoritative, short enough to be extractable, complete enough to be quoted.

Our schema validator flags answers shorter than 50 characters as a warning — a useful reminder when you paste existing FAQs into schema.

Aim for 5–10 Q&A pairs per page

Too few (1–2) makes the page feel thin and gives the AI limited coverage of likely follow-up questions. Too many (20+) dilutes per-question weight and gets interpreted as spam-farming. The 5–10 range matches the actual user intent for most FAQ pages: cover the most common questions, answer them well, link to deeper resources for edge cases.

Match your visible content exactly

The FAQ schema must reflect questions and answers that actually appear on the page in the visible DOM. This is a Google guideline, but it's also enforced by AI engines — they cross-check schema against rendered content and downrank pages with schema content that doesn't appear visibly. No cloaking.

Include entity mentions naturally

Every answer is an opportunity to mention your brand, product, or key entity one additional time. Not stuffed, but naturally. "Our FAQ generator handles this automatically" beats "This type of tool handles this automatically." Every repeated entity reference strengthens your presence in the AI's knowledge graph.

How to generate FAQ schema

Three approaches, in order of increasing effort and control:

Option 1: Use a generator (recommended)

Our FAQ schema generator lets you fill a form with your Q&A pairs and emits validated JSON-LD you can copy directly into your page head. It also includes an AI Readiness Score that flags issues (short answers, missing name/URL, suboptimal phrasing) before you ship.

Option 2: Schema plugin in your CMS

WordPress — Yoast SEO Premium, Rank Math, and Schema Pro all support FAQPage schema from a UI. You write Q&A pairs in the plugin's sidebar; it emits JSON-LD automatically. Works well for content editors who don't want to touch code. Validate the plugin's output periodically because different plugins make different structural choices.

Shopify / Squarespace / Wix — Each platform has its own approach. Most lack native FAQ schema, so you'll paste generator output into custom code blocks. See our detailed WordPress guide for platform-specific instructions.

Option 3: Hand-rolled JSON-LD

For Next.js, React, or any static-site generator, build the FAQPage object from your CMS data at build or render time:

const faqJsonLd = {
  "@context": "https://schema.org",
  "@type": "FAQPage",
  mainEntity: page.faqs.map((f) => ({
    "@type": "Question",
    name: f.question,
    acceptedAnswer: { "@type": "Answer", text: f.answer },
  })),
};

<script
  type="application/ld+json"
  dangerouslySetInnerHTML={{
    __html: JSON.stringify(faqJsonLd).replace(/<\/script>/gi, "<\\/script>"),
  }}
/>

The </script> escape is important — without it, a </script> string inside an answer breaks the HTML parser.

Common FAQ schema mistakes

• Including questions the page doesn't visibly answer. Google and AI engines cross-check.
• Copy-pasting FAQ content from another site. Original Q&A is weighted heavily; duplicated content is deprioritized.
• Stuffing irrelevant questions for keyword coverage. AI engines detect and penalize generic filler Q&As.
• Using answeredAnswer or answerBody instead of acceptedAnswer.text. These are wrong property names; stick to the spec.
• Nesting wrong @types. A Question must have an acceptedAnswer of @type: Answer, not @type: Text or a bare string.
• Leaving <script> encoding broken. Always escape </script> inside answer text.

Run your output through our validator before shipping. It catches all of these and 20+ more FAQ-specific issues.

FAQ schema and other schema types together

FAQPage is perfectly happy to coexist with other schema on the same page. Best practice patterns:

• Article + FAQPage. A blog post with a FAQ section at the bottom. Both schemas render; AI engines use Article for discovery and FAQPage for direct answer citation.
• Product + FAQPage. A product page with "frequently asked questions about this product" section. FAQ answers product-specific queries that product schema doesn't cover.
• LocalBusiness + FAQPage. A business location page with FAQs about hours, parking, accessibility, etc. FAQ covers the "how do I" queries that LocalBusiness attributes can't.
• HowTo + FAQPage. A tutorial with a troubleshooting FAQ section at the bottom. HowTo covers the procedure; FAQ covers "what if something goes wrong."

Use a single @graph array in one script tag to include multiple entity types on the same page, rather than multiple script tags.

Frequently Asked Questions

Is FAQ schema still worth adding after the 2023 Google changes?

Yes, more so than before. The Google rich-result restriction affected one narrow search surface. FAQ schema remains the single highest-leverage structured data format for AI citation — used actively by ChatGPT, Perplexity, Google AI Overviews, Bing, and voice assistants.

How many FAQ pairs should I add per page?

5–10 is the sweet spot for most pages. Fewer feels thin; more dilutes per-answer weight. Pick the questions users actually ask, not keyword variations.

Can FAQ schema work on a page that isn't primarily an FAQ?

Yes. Many pages benefit from adding an FAQ section near the bottom and marking it up. A product page, service page, or blog post with a "frequently asked questions" section at the bottom earns FAQ schema benefits for those specific questions even when the main page content is something else.

Does FAQ schema help with voice search?

Yes, substantially. Voice assistants use FAQ schema for direct answer matching — users who ask spoken questions get replies pulled from FAQ-marked pages more often than unstructured prose. Short, complete, self-contained answers work particularly well for voice.

What's the minimum valid FAQPage schema?

Technically one Q&A pair with a Question (name) and acceptedAnswer (Answer with text). Practically, you want at least 3 substantive pairs to be worth the implementation effort. Below that, AI engines often skip the schema entirely as low-signal.

Should my FAQ schema include the visible question elements on the page?

The schema should describe the same questions that are visible on the page. If your page has a visible "Frequently Asked Questions" H2 with 5 expanding accordion items, the schema should contain exactly those 5 questions with their exact text. Diverging from visible content violates Google's guidelines and confuses AI engines.

Can I have multiple FAQPage scripts on the same page?

Not recommended. Pick one FAQPage per page with all your questions in its mainEntity array. Two separate FAQPage declarations for the same URL confuses crawlers and reduces the overall signal.

How do I update FAQ content without breaking schema?

Use a single source of truth. Store your Q&A pairs in your CMS or content database, then generate both the visible FAQ section and the schema from the same data at build or render time. This makes drift impossible. For manual workflows, re-run your page through our validator after every content update.

---

FAQ schema is the most cost-effective piece of structured data most sites aren't implementing correctly. Ten to thirty minutes per page, the same content you were probably going to write anyway, validated and emitted as JSON-LD — and the result is disproportionate AI citation visibility for years.

Start with our generator. Validate with our validator. Roll out across your site one page at a time, starting with the highest-traffic content. The compounding effect over a quarter is substantial.