FAQPage schema

FAQPage declares authorship. It says the site owner wrote both the question and its single authoritative answer, which is why the structure allows exactly one acceptedAnswer per Question and no alternatives. That is the correct type for a support page, a pricing FAQ, or a documentation section where you are the authority on what the answer is. It is the wrong type the moment more than one answer is legitimate.

QAPage is the type it gets substituted for, and it describes a genuinely different object: one user-submitted question with community answers competing beneath it. It supports suggestedAnswer alongside acceptedAnswer, plus upvote counts, because the whole point is that several answers exist and the crowd is ranking them. A forum thread is a QAPage. Your pricing page is not, no matter how many questions it lists. Using QAPage for owner-authored content misrepresents where the answer came from, and using FAQPage for a forum thread claims an authority the page does not have.

The other thing to unlearn is that FAQPage is a rich-result play. It was, from Google's 2019 rollout until August 2023, when FAQ rich results were narrowed to well-known authoritative government and health sites — the same period in which HowTo lost its rich result entirely. For everyone else the visual reward is gone and the markup still matters, because a language model parsing a page benefits from explicit question-answer pairs whether or not Google decorates the listing. The type outlived its own SERP feature.

FAQPage carries four points in the AIRank rubric, the largest single line item in schema coverage, and the check is scoped rather than global: it asks whether at least one high-intent page carries valid FAQPage markup. High-intent means pricing, comparison, integration and product pages — the ones a buyer reads while deciding. Marking up a contact page earns nothing, because nobody asks a model a question the contact page answers.

Three quality gates sit beneath the point. Visible parity is binary and non-negotiable: every question and every answer in the JSON must appear in the rendered HTML, because Google's structured-data policies require marked-up content to be visible and this is the type where hidden content is most tempting. Answer length wants to land between forty and a hundred and twenty words, the same window that governs extraction generally. And the block must validate cleanly, since a malformed Question node discards the entire FAQPage object rather than just that entry.

Below is a two-question FAQPage block as it would ship on a pricing page. Note that the answers are prose written to stand alone rather than pointers back into the page — an answer reading "see the table above" is technically valid markup and useless once extracted.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How often does a connected site get re-scanned?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Connected sites are re-scanned on a schedule set by your plan, and you can trigger a manual re-scan at any time from the site settings page. Each scan re-runs the full 47-point audit and a fresh citation sweep, so the score and the tracker move together rather than drifting apart."
      }
    },
    {
      "@type": "Question",
      "name": "Do I need to install a plugin to use AIRank?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Scanning and citation tracking work against any public URL with no code installed. The WordPress plugin and Shopify app are only required for automatic fix deployment, which writes schema and llms.txt changes directly to the site instead of handing you a diff to apply yourself."
      }
    }
  ]
}
</script>

Three things make this block worth shipping. The question strings are phrased the way someone types them, not the way a marketer would title a section — "do I need to install a plugin" rather than "Flexible deployment options". Each answer is a complete capsule in the forty-to-a-hundred-and-twenty-word window, so it survives being lifted out. And both pairs exist verbatim in the visible page below the fold, which is what keeps the markup compliant rather than merely valid.

• The invisible-answer trap. A plugin generates FAQPage JSON from a spreadsheet of questions that never render on the page, or the answers sit inside collapsed accordions that ship no text in the initial HTML. It validates, so nobody notices. Google's structured-data policies require the marked-up content to be visible, which makes this a manual-action risk rather than an optimisation. The fix is a parity assertion in CI: every string in the JSON must be findable in the rendered HTML of the same URL.
• The marketing question. The block asks "Why choose our platform?" and "What makes us different?", which are headings wearing question marks. No buyer types them, so they match nothing, and the answers beneath them are positioning rather than information. The fix is to source questions from support tickets, sales calls and search console queries, then keep the buyer's own phrasing intact even where it is clumsier than what a copywriter would write.
• The sitewide FAQ block. Someone adds the same five-question block to a template, so two hundred URLs now emit identical FAQPage markup. Every page competes with every other for the same question, and the near-duplicate structure is exactly the signal that gets a cluster of pages dropped from an index. The fix is to scope FAQ blocks to the pages where those specific questions are the point, and let each page carry questions nothing else on the site answers.

What the table cannot show is that two of these rows share a history worth learning from. FAQPage and HowTo both lost their Google rich results in 2023, and both remain worth shipping, which is the clearest available evidence that structured data and search decoration are separable concerns. The reason to write FAQPage markup today is that it hands a parser pre-segmented question-answer pairs at zero inference cost. That benefit is unaffected by what Google chooses to render, and it is why the type is still the largest single line item in schema coverage.