FAQ Schema: How to Get Rich Snippets in Google Search

FAQ schema is the JSON-LD vocabulary that defines question and answer pairs on a page so search engines can parse them as structured entities. The markup itself remains a stable schema.org type. However, what FAQ schema actually delivers in Google search results changed dramatically in August 2023, and many implementation guides still describe a world that no longer exists.

This guide separates current reality from outdated advice. You will learn what the markup looks like today, where it still earns visibility despite the rich result restrictions, how to write valid JSON-LD that passes both Google and schema.org validators, and when adding it is simply not worth the maintenance burden.

What FAQ Schema Is (and What It Looks Like in SERPs)

FAQ schema is a structured data type defined by schema.org as FAQPage. It tells search engines that a page contains a list of canonical questions, each paired with an authoritative answer from the publisher. The schema itself is independent of any single search engine, even though Google’s interpretation drives most implementation decisions.

Historically, valid FAQ schema produced an expandable accordion directly in search results. Each question appeared as a clickable row, and clicking expanded the answer inline without leaving the SERP. That visual treatment significantly increased SERP real estate for participating pages.

Today, the visible rich result is largely retired. Yet the underlying markup remains useful, and the difference between “rich result” and “machine-readable structured data” matters more than ever as AI-driven features reshape search.

The Reality: FAQ Rich Results Are Largely Gone

On 8 August 2023, Google announced a major change to FAQ rich result eligibility. As documented in the Google Search Central blog post, the company restricted FAQ rich results to “well-known authoritative government and health websites” only. Every other site lost the visible accordion treatment, even when their markup remained perfectly valid.

The change was not a penalty. Existing FAQ schema kept passing the Rich Results Test as syntactically correct. Google simply stopped rendering the rich result for the vast majority of domains. Therefore, an SEO team can have flawless markup and zero SERP impact from it.

The same announcement also restricted HowTo rich results to desktop and significantly narrowed their eligibility. John Mueller has confirmed in multiple subsequent statements that the change was deliberate and aimed at reducing SERP clutter. As a result, expecting an FAQ accordion on a typical commercial site is no longer realistic.

Where FAQ Schema Still Earns Visibility

FAQ markup is not dead. Its value has shifted from SERP cosmetics to entity understanding. Several surfaces still consume FAQPage data, even when the classic accordion does not appear.

• AI Overviews and AI Mode. Google’s generative answer features pull from structured Q&A pairs when summarizing topics. Clean FAQ markup makes a page easier to cite.
• Voice search and assistants. Google Assistant, Alexa skills, and similar systems prefer pre-structured Q&A data over scraping prose.
• Knowledge graph signals. FAQ schema reinforces entity relationships and answers Google may surface in People Also Ask boxes.
• Internal site search and chatbots. Many headless commerce platforms now consume FAQPage markup as a data source for on-site chat agents.
• Bing and other search engines. Bing still occasionally renders FAQ-style enhancements where Google does not.

In short, the markup remains a low-cost signal that compounds across surfaces, even though no single surface guarantees visibility. For pages that already have well-organized question and answer content, adding the schema is still worthwhile. For pages where you would invent FAQ content solely to add markup, it is not.

FAQ Schema vs Q&A Schema vs HowTo

FAQPage is one of three closely related schema types. Choosing the wrong one is a common implementation error, so the distinction matters.

For instance, a product page with five questions written by the brand uses FAQPage. Conversely, a help forum thread with one question and many user-submitted answers uses QAPage. A recipe or assembly guide uses HowTo (though HowTo rich results are also restricted).

Anatomy of Valid FAQ Schema

Valid FAQ schema has three nested levels: a FAQPage root, an array of Question nodes, and an acceptedAnswer on each question. Below is a minimal but compliant example.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is FAQ schema?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "FAQ schema is JSON-LD structured data that marks up question and answer pairs so search engines can parse them as discrete entities."
      }
    },
    {
      "@type": "Question",
      "name": "Does FAQ schema still produce rich results?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Since August 2023, only government and health authority sites are eligible for the expandable rich result in Google."
      }
    }
  ]
}
</script>

Three rules govern every valid implementation. First, the name property on each Question must be the literal question text. Second, the text property on each Answer must contain the full answer body, with HTML tags allowed. Third, both question and answer must be visible to users on the page, not hidden in JavaScript-only state.

For deeper coverage of JSON-LD syntax patterns, see our JSON-LD structured data developer guide, which walks through the underlying serialization format.

Implementation: Static HTML, WordPress, Headless

The same JSON-LD payload works across stacks, but the injection mechanism differs.

Static HTML

Place the <script type="application/ld+json"> block anywhere in the document. The <head> is conventional, though Google explicitly states that body placement is also accepted. Keep the script as close to the corresponding visible content as possible for maintenance clarity.

WordPress

Most SEO plugins (Yoast, Rank Math, The SEO Framework) include FAQ block patterns that emit valid JSON-LD automatically when you add a corresponding visible block. Manual injection is also possible via the wp_head hook in your theme’s functions.php, which gives finer control over conditional output. Avoid stacking plugin-generated and manual schema on the same page, since duplicate FAQPage entities trigger validation errors.

Headless and Single Page Apps

Server-side rendering or static site generation must include the JSON-LD in the initial HTML response. Google’s rendering pipeline does run JavaScript, but relying on client-side schema injection introduces race conditions and inconsistent indexing. Frameworks like Next.js expose helper components such as next/head or third-party libraries like next-seo for this purpose.

Common Validation Errors

Validation failures fall into a small number of recurring patterns. Recognizing them up front saves debugging time later.

1. Hidden answers. Content collapsed inside tabs or accordions that are closed by default fails Google’s visibility requirement. The text must be present in the rendered DOM, even if styled as collapsible.
2. Duplicate questions. Two Question nodes with identical name values within the same FAQPage trigger a validation error. Each question must be unique.
3. Multiple FAQPage blocks on one URL. If both your SEO plugin and a custom theme function emit FAQPage schema, Google sees conflicting entities. Audit the rendered HTML, not just the source you wrote.
4. Promotional content disguised as Q&A. Google’s policy prohibits FAQ schema for advertising, lead generation forms, or sales pitches. Genuine informational Q&A is the only acceptable use.
5. Schema text mismatched with visible text. The answer text in JSON-LD must mirror what users see. Substantively different content between markup and page is a frequent rejection cause.
6. HTML in the wrong place. The text property may contain inline HTML, but the name property must be plain text only. Tags inside the question name break parsers.

Testing with Rich Results Test and Schema Markup Validator

Two complementary tools cover schema validation. Each catches a different class of issue, so use both.

The Rich Results Test from Google checks whether your markup is eligible for any rich result feature. For FAQPage, it confirms structural validity even though most sites cannot earn the rich result itself. Eligibility status appears in the response.

The Schema Markup Validator from schema.org checks pure schema compliance independent of Google’s eligibility rules. It catches type errors, missing required properties, and malformed nesting that the Rich Results Test sometimes misses.

For routine audits, paste the page URL into both validators in sequence. If you maintain many pages, our Schema Markup Generator produces ready-to-paste JSON-LD for FAQPage and seven other types, which reduces hand-coding errors.

Maintenance: Versioning FAQ Content as Pages Evolve

FAQ content drifts. Product features change, policies update, and the answer that was correct last quarter may now mislead users. Therefore, schema maintenance is an ongoing discipline, not a one-time setup task.

• Version control the source. Treat FAQ entries as content that lives in your CMS or repository, not in plugin configuration only. Diffs reveal when answers shift.
• Re-validate after major edits. A copy change to an answer that introduces invalid characters or breaks the JSON structure is the most common cause of newly-broken schema.
• Audit duplicate questions across pages. If multiple pages claim canonical answers to the same question, decide which page owns it and consolidate.
• Sync with help center and chatbot data. Many organizations maintain three separate Q&A sources (website FAQ, help docs, chatbot training). Discrepancies confuse both users and AI summarizers.
• Quarterly review. A 30-minute review per quarter to retire stale entries and add new ones keeps the schema useful without becoming a maintenance burden.

For broader context on how structured data integrates with your overall SEO program, our schema markup beginner’s guide covers the strategic picture.

When NOT to Use FAQ Schema

Adding markup for the sake of having markup is a common antipattern. Several scenarios make FAQ schema actively counterproductive.

• Invented questions. If you are writing fake questions to wrap your sales copy in schema, you violate Google’s policy and risk a manual action.
• Single-question pages. One question and one answer is more naturally an article or a definition. FAQPage implies a list.
• Pages where Q&A is not the primary content. A blog post that mentions one FAQ-style aside is not an FAQ page. Reserve the schema for pages whose dominant purpose is Q&A.
• User-generated forums. Use QAPage instead, since FAQPage assumes publisher authorship.
• Promotional content. Lead capture forms, product pitches, and pricing comparisons disguised as questions are explicitly prohibited.
• Heavy maintenance with low return. If your team cannot commit to keeping the FAQ content accurate, the schema becomes a liability when answers go stale.

Aleyda Solis has noted in her writing on structured data strategy that the right question is not “can we add this schema?” but “does this schema accurately describe the user-facing content?” That framing prevents most policy violations.

Bottom Line

FAQ schema in 2026 is a quieter signal than it was three years ago. The visible accordion is gone for almost everyone, but the markup still feeds AI Overviews, voice assistants, knowledge graph relationships, and internal site search systems. For pages with genuine, well-organized Q&A content, the cost of valid implementation is low and the cumulative benefit across surfaces is real. For pages where FAQ content would be invented, the markup is at best wasted effort and at worst a policy violation.

If you are ready to generate compliant JSON-LD for your FAQ pages without hand-writing every nested object, our Schema Markup Generator outputs ready-to-paste FAQPage markup along with seven other schema types. Validate the result with both Google’s Rich Results Test and the schema.org validator before deployment, and revisit the markup quarterly to keep it aligned with the page content it describes.