Blog about GEO and SEO

How to add FAQPage schema markup so AI assistants quote your answers

FAQPage schema is a block of JSON-LD code that labels each question and answer on your page so machines can read them as discrete question–answer pairs. Add it to pages that already show visible FAQs, keep each answer self-contained and 40–60 words long, and you give AI assistants a clean, quotable unit of text instead of forcing them to guess where your answer starts and ends. The markup alone does not guarantee a citation, but it removes ambiguity – and ambiguity is the main reason good answers get skipped.

FAQPage is a schema.org type that describes a page containing a list of questions, each with one accepted answer. It is usually implemented as JSON-LD inside a <script type="application/ld+json"> tag in the page's <head> or <body>.

In 2023 Google limited FAQ rich results in classic search to a narrow set of well-known government and health sites, so most sites no longer get the expandable accordion in the SERP. That change made many teams delete their markup – which was a mistake for a different reason: the markup is still machine-readable structured data, and the systems that build AI answers consume structured data from the page they crawl.

The practical value today is not a rich snippet. It is disambiguation: an explicit statement that "this string is the question, that string is the answer", which helps any parser – Google's, Bing's, or an LLM's retrieval pipeline – extract a short, quotable passage.

Do AI assistants actually read schema.org markup?

Partly, and the details differ between services. ChatGPT's browsing, Perplexity, and Copilot fetch the HTML of a page and pass a cleaned version to the model; JSON-LD is part of that HTML and often survives extraction, but none of these vendors publishes a guarantee that it is weighted.

What is well established: Google and Bing parse structured data as a documented ranking and understanding input, and Google AI Overviews are built on top of Google's existing index. So markup definitely reaches the classic-search side of the AI answer stack.

For the LLM side, treat schema as a supporting signal, not a magic switch. The bigger lever is the visible text: AI assistants quote what they can read on the page. Markup that mirrors visible, well-structured text helps; markup that contradicts the page can be ignored or flagged as spam.

What qualifies as a valid FAQ for FAQPage markup?

Google's documented rule is simple: FAQPage is for pages where the site itself publishes both the question and its answer, and users cannot submit alternative answers. If users can answer, that is QAPage, a different type.

Use FAQPage when:

  • The questions and answers are visible on the page to a normal visitor, in the same wording as the markup.
  • There is exactly one answer per question, authored by you.
  • The content is genuinely informational, not an advertisement dressed as a question.

Do not use it for product review threads, forum pages, or a "FAQ" block that only exists in the code. Invisible markup is a structured data policy violation and the most common reason FAQ markup gets ignored.

How do you add FAQPage schema step by step?

  1. Pick the page. Start with pages that already answer questions: service pages, pricing, documentation, a support article, or a dedicated FAQ page.
  2. Write or clean the visible FAQ block. Each question becomes a heading (<h3> works well), each answer a short paragraph directly under it.
  3. Cut each answer to a self-contained 40–60 words that makes sense with no surrounding context.
  4. Generate the JSON-LD with the exact same text as the visible block.
  5. Insert the script in <head> or at the end of <body>. Both are valid; <head> is safer if your page renders content with JavaScript.
  6. Validate with the Schema.org validator and Google's Rich Results Test.
  7. Re-check after any CMS or template change – themes frequently strip or duplicate script tags.

What does a correct FAQPage JSON-LD look like?

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does a site audit take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A standard audit of a site under 500 pages takes 24 to 48 hours. Large sites with multiple languages or subdomains take up to five working days, because each language version is crawled separately."
      }
    },
    {
      "@type": "Question",
      "name": "Do I need to give access to my server?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. The audit works from publicly available pages only. Server or CMS access is optional and is used solely to apply fixes you approve."
      }
    }
  ]
}
</script>

Notes on the fields:

  • name is the question, as plain text. No HTML.
  • text is the answer. Basic HTML is allowed by Google – <p>, <br>, <ol>, <ul>, <li>, <a>, <b>, <em> – but plain text is safer for LLM extraction.
  • Escape double quotes inside strings as \" and never leave a trailing comma; a single syntax error invalidates the whole block.

Can one page have FAQPage plus another schema type?

Yes. The cleanest approach is an @graph array that holds several top-level entities, so your Article or Product markup and the FAQ coexist without conflict.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Article",
      "headline": "How to add FAQPage schema markup",
      "author": { "@type": "Organization", "name": "Zgadka" },
      "datePublished": "2024-01-01"
    },
    {
      "@type": "FAQPage",
      "mainEntity": [
        {
          "@type": "Question",
          "name": "Is FAQPage schema still useful?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Yes. It no longer produces rich results for most sites, but it still labels question-answer pairs for search engines and AI retrieval systems."
          }
        }
      ]
    }
  ]
}
</script>

Only one FAQPage block per page. Two blocks with overlapping questions is a common duplication error from plugins.

JSON-LD, Microdata or RDFa – which format should you use?

FormatWhere it livesReadability for parsersMaintenanceRecommendation
JSON-LDSeparate <script> tagHigh – one self-contained blockEasy, independent of markupUse this
MicrodataAttributes on HTML tagsMedium – parser must walk the DOMBreaks when templates changeLegacy only
RDFaAttributes on HTML tagsMediumVerboseRarely worth it

Google supports all three, but JSON-LD is the format it recommends, and it is far easier for an LLM pipeline to lift intact.

How do you write answers that AI assistants will quote?

Lead with the answer. The first sentence should resolve the question without conditions; details follow. Assistants frequently quote only the first one or two sentences.

Keep each answer self-contained. Avoid "as mentioned above", "this feature", or "it depends on the plan described earlier" – a quoted fragment loses that context and becomes useless.

Use concrete nouns and numbers rather than vague claims. "Takes 24 to 48 hours" is quotable; "is usually quite fast" is not. If you cite a figure, make sure the page states the source or the date it applies to.

Match question wording to real queries. Write questions the way people type or speak them – "How much does X cost?" beats "Pricing information". Pull candidates from Search Console queries, support tickets, and sales calls.

Repeat the entity name. Inside answers, say "Zgadka audits…" rather than "we audit…" at least once per page, so a quoted fragment still identifies who is speaking.

What are the most common FAQPage mistakes?

  • Markup text that does not match visible text, word for word.
  • Hidden FAQ content behind a tab or accordion that is not in the HTML at all until a click triggers a fetch.
  • Multiple acceptedAnswer objects for one question – only one is allowed.
  • Marketing copy or a call to action inside the text field.
  • Two plugins both injecting FAQPage, creating duplicates.
  • Invalid JSON – unescaped quotes, smart quotes copied from a word processor, trailing commas.
  • The same FAQ block copied onto dozens of pages, which dilutes topical relevance.

How do you test and monitor FAQ markup?

  1. Run the page through validator.schema.org for syntax and type errors.
  2. Run Google's Rich Results Test to see what Google can parse.
  3. Check Search Console's structured data reports for errors at scale.
  4. View the page as a crawler would: fetch the raw HTML with curl and confirm the script tag is present without JavaScript execution.
  5. Ask an AI assistant your own question and see whether it cites your page, and whether the wording matches your answer text.

Step 5 is the real test. If the assistant paraphrases something close to your answer but cites a competitor, the problem is usually authority or crawl access, not markup.

What else makes your answers quotable besides schema?

Let AI crawlers in. Many sites block them by accident with a blanket disallow. A permissive baseline looks like this:

User-agent: GPTBot
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: *
Allow: /
Sitemap: https://example.com/sitemap.xml

Blocking Google-Extended does not remove you from AI Overviews, which rely on the normal Googlebot crawl – a distinction many teams get wrong. Check your own list of agents against current vendor documentation, since names change.

Consider an llms.txt file at the root. It is a proposed convention, not an adopted standard, and support is not guaranteed – but it costs nothing and gives a clean map of your key pages.

# Example Inc.

> B2B analytics software for logistics teams.

## Core pages
- [Pricing](https://example.com/pricing): plans, limits, billing terms
- [FAQ](https://example.com/faq): answers to the 20 most common questions
- [Docs](https://example.com/docs): API reference and integration guides

Finally, make sure the page is fast, server-rendered, and reachable without a login. An assistant that times out on your page cites someone else.

FAQ

Does FAQPage schema still get rich results in Google?

For most sites, no. Google restricted FAQ rich results to a small set of authoritative government and health sites in 2023. The markup remains valid structured data and is still worth adding for machine readability.

How many questions should one FAQPage block contain?

Between three and ten for a typical page. Fewer than three rarely justifies the markup; more than ten usually means you should split the content into separate topic pages that each answer a question properly.

Can I put FAQPage markup on a product or category page?

Yes, if the questions and answers are genuinely visible on that page and relate to it. Combine them with your Product markup in an @graph array, and do not reuse the same FAQ text across every product.

Will markup alone get me cited by ChatGPT or Perplexity?

No. Citation depends mainly on whether the crawler can access the page, whether the answer is clear and specific, and whether the site is a plausible authority on the topic. Schema helps extraction; it does not create authority.

Should answers in the markup be identical to the visible text?

Yes, word for word. Mismatched markup is a policy violation and risks being ignored entirely. If you want a shorter version for machines, shorten the visible text too.

If you want to know which of your pages AI assistants can actually read and quote, run a free check in Zgadka – it scores your site on GEO and SEO, flags missing or broken schema, and hands you ready-made files to fix it.


Fazier badge