FAQPage Schema (JSON-LD) for AI Citations: A Practical Guide

FAQPage schema is a piece of JSON-LD structured data that marks up a page's questions and answers in a format search engines and AI systems can parse without guessing. It no longer reliably earns Google's visual FAQ rich snippet, but it still gives ChatGPT, Perplexity, and AI Overviews a clean, attributable answer to extract and cite. Here is how to implement it correctly.

What FAQPage Schema Is (and Why AI Engines Care About It)

FAQPage is a type defined by schema.org, the shared vocabulary search engines and AI companies use to interpret web content. Per schema.org's own definition, a FAQPage is a WebPage presenting one or more frequently asked questions — a curated list written by the page owner, each paired with a single official answer.

That detail — one accepted answer per question, authored by the publisher — separates FAQPage from its schema.org cousin, QAPage, which models community Q&A threads (forums, Stack Overflow-style pages) with multiple user-submitted answers and votes. A support, product, or informational FAQ you wrote and control belongs under FAQPage; user-submitted, unmoderated content does not.

Structurally, FAQPage is built from three nested schema.org types:

• FAQPage — the container, applied once per page
• Question — one per Q&A pair, using the name property for the question text
• Answer — nested inside acceptedAnswer, using the text property for the answer content

That is the entire core vocabulary. No required images, ratings, or vote counts — just a question, its accepted answer, and the page they live on.

Why AI answer engines lean on this structure

Generative engines — ChatGPT, Perplexity, Google AI Overviews, Gemini, Copilot — all face the same problem at scale: given a raw web page, decide what it is about, which parts are safe to quote, and who to attribute the quote to. Normally that means inferring structure from HTML layout and heading hierarchy, which is slow and error-prone at web scale.

JSON-LD skips that inference step. It is a deterministic, out-of-band signal sitting in a <script> tag: this exact string is a question, this exact string is its accepted answer, full stop. A retrieval or indexing system does not need to guess whether a paragraph is an FAQ answer, a caption, or a pull-quote — the markup already says so. That lowers the cost of extraction and increases the odds that the exact text you wrote is the text that gets quoted, rather than a paraphrase assembled from surrounding page noise.

This does not mean unstructured Q&A content is invisible to AI systems — plenty of FAQ sections with zero markup still get summarized and cited. As one industry analysis of how LLMs parse content put it, schema is "a helpful boost, not a magic bullet": it clarifies intent for systems already favoring Q&A-formatted content; it does not manufacture visibility out of thin air. Google has separately confirmed its AI-powered search features use structured data as a comprehension signal, on top of whatever they infer from the rendered page.

The practical takeaway: FAQPage markup does not guarantee a citation, but it removes ambiguity at exactly the moment an AI system decides whether your content is clear enough to quote.

A Complete, Valid FAQPage JSON-LD Example

Below is a minimal, valid FAQPage block for a SaaS pricing and support page, built strictly from the properties schema.org defines for FAQPage, Question, and Answer:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Does the free plan include API access?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. The free plan includes read-only API access with a limit of 1,000 requests per month. Write access and higher rate limits are available on paid plans."
      }
    },
    {
      "@type": "Question",
      "name": "Can I cancel my subscription at any time?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. You can cancel from your account settings at any time. Your plan remains active until the end of the current billing period, and no further charges are made after cancellation."
      }
    },
    {
      "@type": "Question",
      "name": "What happens if I exceed my monthly usage quota?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Requests beyond your plan's monthly quota are queued rather than rejected. You will receive an email notification, and you can upgrade your plan at any time to increase your limit immediately."
      }
    },
    {
      "@type": "Question",
      "name": "Is customer data encrypted at rest and in transit?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. All data is encrypted in transit using TLS 1.2 or higher, and encrypted at rest using AES-256."
      }
    }
  ]
}

Place that object inside a script tag in the page's <head> or <body>:

<script type="application/ld+json">
  { ... the JSON object above ... }
</script>

A few implementation notes that follow directly from the schema:

• @context is always the string "https://schema.org". Without it, parsers cannot resolve what FAQPage or Question mean.
• mainEntity takes an array of Question nodes — beyond @type, the only property FAQPage strictly needs.
• name on a Question is the question text itself, not a page title or slug.
• acceptedAnswer expects a single Answer node, matching schema.org's own description of the property as "the answer that has been accepted as best."
• text on the Answer is the full answer content, inherited from the generic CreativeWork.text property.

Everything else defined on these types — answerCount, upvoteCount, dateCreated, url — is optional and mostly relevant to community Q&A (QAPage), not a publisher-authored FAQ. Keep the object minimal.

Common FAQPage Implementation Mistakes

Most FAQPage problems come from treating the markup as a growth hack rather than an accurate description of the page. Google's structured data guidelines are explicit here, and the same principle applies to any system trusting your JSON-LD: don't mark up content invisible to readers, and don't mark up irrelevant or misleading content.

1. Marking up content that is not visible on the page

The single most common violation: adding Q&A pairs to the JSON-LD that never appear as readable text on the page. If a visitor cannot find the question and its full answer in the rendered content, the markup misrepresents the page — a mismatch that erodes trust with Google and with any AI crawler cross-checking claims against what is actually visible.

2. Duplicate or near-duplicate questions

Repeating the same question with slightly different phrasing, or stamping an identical FAQ block onto dozens of near-identical pages, reads as padding rather than genuine answers. Keep each question distinct and answer it once, well.

3. One FAQPage doing too much

Google's guidance limits FAQPage markup to one instance per page. If a page has several independent Q&A modules, consolidate them into a single mainEntity array rather than emitting multiple FAQPage blocks.

4. Using FAQPage for content Google's policies exclude

Ads and unmoderated, user-generated Q&A content are not appropriate uses of FAQPage. If your "FAQ" is really a comment thread or forum, model it differently — that is what QAPage exists for.

5. Treating the visual rich snippet as the goal

Worth spelling out in detail, because the landscape genuinely shifted twice in three years and a lot of advice still circulating online is stale.

In August 2023, Google restricted the visual FAQ rich result — the expandable question list once shown directly in search results — to "well-known, authoritative government and health websites," as its Search Central blog put it. For everyone else, the rich snippet effectively disappeared overnight, even with flawless markup.

Then, in May 2026, Google removed the FAQ rich result entirely, for every site, including the government and health domains that had kept it. Its own FAQPage documentation now states plainly that FAQ rich results are no longer appearing in Google Search; the Search Console filter, the rich result report, and FAQ support in the Rich Results Test followed in June, with Search Console API support due to end in August 2026.

What Google has not done is deprecate the FAQPage type itself or stop parsing it. Existing markup causes no harm and remains valid schema.org vocabulary. Google has separately confirmed its AI-powered search features still use structured data as a comprehension signal, and other AI crawlers and answer engines set their own policies independently of Google's rich-result decisions anyway.

The honest framing: if you implemented FAQPage purely to chase the expandable blue snippet, that specific payoff is gone for essentially everyone now. If you implemented it to make Q&A content legible to retrieval and answer-generation systems, the case is unaffected — arguably stronger, since AI answer surfaces are a growing share of how people encounter your content in the first place.

How to Choose the Right Questions to Cover

FAQPage schema amplifies whatever you put into it — including bad question selection. Before writing markup, get the underlying question set right.

Start from real queries, not assumptions

Pull the actual questions your audience asks: sales call transcripts, support tickets, live chat logs, on-site search, and "People also ask" boxes for your core topics. These reflect real phrasing and intent — AI systems retrieve based on semantic closeness to how people actually ask things, not how you would prefer to phrase them internally.

Prioritize questions with a single, factual, extractable answer

FAQPage rewards concision. "What is your refund policy?" with a two-sentence, unambiguous answer is a strong candidate. A question that genuinely needs nuance or "it depends" caveats is a weaker fit — simplify it into a clean-answer version, or move the nuanced case into full article content instead.

Cover the questions that block a decision or a purchase

Prioritize questions close to commercial intent: pricing mechanics, eligibility, compatibility, security, cancellation terms. These are exactly what an AI assistant is likely to be asked on your behalf, and a precise, citable answer increases the odds your brand, not a competitor's, is the one quoted back.

Do not force every page into an FAQ

Not every page needs FAQPage markup. A deep how-to guide or comparison article is usually better served by Article or HowTo schema, with a small FAQ section appended only if real recurring questions exist — not manufactured ones added just to use the schema.

Keep the list current

Questions age. Pricing changes, features ship, policies update. An FAQPage answering last year's plan structure is worse than no FAQPage at all, because it actively misinforms anything that cites it, including AI systems with no way to know the answer is stale.

How to Validate Your FAQPage Markup

Once the JSON-LD is live, verify it renders correctly and parses cleanly before assuming it is working.

1. Run it through the Rich Results Test

Google's Rich Results Test, at search.google.com/test/rich-results, is the tool its own documentation recommends for validating structured data. Paste your page URL or the raw code, and it flags missing required properties, malformed nesting, and syntax errors against schema.org and Google's requirements.

Since FAQ-specific rich-result preview support is being phased out of the tool through mid-2026, treat it now primarily as a markup validator — confirming your JSON-LD parses without errors — rather than a preview of a visual search feature.

2. Check it during development, not after launch

Google's recommended workflow is to validate during development, then monitor with rich result status reports after deployment, since pages can break due to templating or serving issues. Catching a broken acceptedAnswer nesting in staging costs minutes; finding it three months into production costs three months of bad markup.

3. Confirm the page actually renders what the markup claims

Validators check JSON syntax and required properties, not whether that text actually appears as visible content. That check is manual: confirm every question and answer in your JSON-LD is readable without clicks, hidden accordions, or client-side-only JavaScript a crawler might not execute.

4. Spot-check with the URL Inspection tool

For indexed pages, Search Console's URL Inspection tool confirms what Google has actually discovered on a live URL — useful for catching a caching layer serving stale markup.

5. Lint the JSON itself

Before any of the above, confirm the object is syntactically valid JSON: matched braces, no trailing commas, correctly escaped quotes inside answer text. One malformed character means the entire block fails to parse.

FAQ

Does FAQPage schema still help if the visual rich snippet is gone?

Indirectly. The visual snippet is gone for essentially all sites as of May 2026, but the markup still helps Google's and other engines' systems parse your page structure, and it remains a valid, actively-supported schema.org type outside that one visual feature.

Is FAQPage the same as QAPage?

No. FAQPage is a single set of official answers written by the page owner. QAPage models community Q&A threads with multiple user-submitted answers and votes, such as forum pages. Using FAQPage for unmoderated, user-generated content goes against Google's guidelines.

How many questions should one FAQPage block include?

There is no fixed minimum or maximum in the schema.org or Google specifications. Include only questions genuinely answered as visible content on that page — a handful of real questions outperforms a padded list of manufactured ones.

Can I use FAQPage markup on more than one page?

Yes, as long as each page has its own block reflecting the questions actually visible on that specific page. Avoid duplicating the exact same Q&A block, verbatim, across many pages purely to add markup somewhere.

Does adding FAQPage schema guarantee my content will be cited by ChatGPT or Perplexity?

No. No structured data type guarantees citation from any AI engine. It removes ambiguity about what is a question and what is its answer, making extraction easier and more precise — but relevance, trust, and content quality still decide whether the content gets used at all.

Sources

• FAQPage - Schema.org Type
• Question - Schema.org Type
• Answer - Schema.org Type
• FAQPage structured data — Google Search Central
• General Structured Data Guidelines — Google Search Central
• Intro to How Structured Data Markup Works — Google Search Central
• Changes to HowTo and FAQ rich results — Google Search Central Blog, August 2023
• Google to no longer support FAQ rich results — Search Engine Land
• How LLMs Interpret Content: How To Structure Information For AI Search — Search Engine Journal