How to Add FAQ Schema to Your Pages

FAQ schema is structured code that explicitly marks each question and answer on a page so search engines can identify them directly. Instead of inferring that a block of text contains a question and its answer, a search engine reading FAQ schema knows with certainty which text is the question and which text is the answer.

This matters for AI search engines in particular. Tools like Google AI Overviews and Perplexity actively extract question-and-answer content from web pages to use in generated responses. FAQ schema makes that extraction more reliable by labelling the content clearly.

This guide explains what FAQ schema includes, how to write it, and how to add it to your pages.

For an overview of schema types and how schema markup works, read What is Schema Markup?

What FAQ Schema Does

FAQ schema uses the FAQPage type from Schema.org. It marks a page - or a section of a page - as containing frequently asked questions, with each question and its corresponding answer identified individually.

When Google detects valid FAQPage schema, the page may be eligible to display as an expandable FAQ result in search - where individual questions appear beneath the main search listing and users can expand each one to read the answer without leaving the search results page.

FAQ schema does not guarantee this appearance. Google decides when to show it based on query relevance and other signals. But the schema is a prerequisite - without it, the page is not eligible regardless of how well the FAQ section is written.

Beyond rich results eligibility, FAQ schema makes question-and-answer content more accessible to AI search systems. A well-written FAQ section with correct schema is one of the more reliable ways to have your content extracted and cited in AI-generated answers.

What FAQ Schema Includes

FAQPage schema has a straightforward structure. The page-level type is FAQPage, and each question-answer pair is represented as a Question entity with an acceptedAnswer.

The required fields are:

• @type: FAQPage at the page level
• mainEntity: an array containing each question
• @type: Question for each question entry
• name: the question text
• acceptedAnswer: contains the answer
• @type: Answer within the acceptedAnswer
• text: the answer text

The FAQ Schema Template

Here is a complete FAQPage schema template with two questions. Add or remove question blocks to match the number of questions on the page:

<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 structured code that labels each question and answer on a page so search engines can identify and extract them directly."
      }
    },
    {
      "@type": "Question",
      "name": "Does FAQ schema improve rankings?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "FAQ schema does not directly improve rankings. It makes pages eligible for FAQ rich results in Google search and helps AI search engines extract question-and-answer content more reliably."
      }
    }
  ]
}
</script>

Replace the name value with the exact question text as it appears on the page. Replace the text value with the full answer. Each question block follows the same pattern - copy and paste it for each additional question, separating blocks with a comma.

Writing the Answer Text for Schema

The text field in the acceptedAnswer should contain the full answer as plain text.

A few rules for writing the answer text:

Match the on-page answer closely. The schema answer does not need to be word-for-word identical to what appears on the page, but it should accurately represent the answer. Significant differences between the schema answer and the visible answer can trigger validation warnings.

Use plain text only. The text field does not support HTML formatting. Do not include heading tags, bold tags, or links inside the answer text. Write it as a clean, plain-text sentence or paragraph.

Keep it self-contained. The answer should make sense on its own without requiring the reader to have read the rest of the article. This is consistent with how FAQ sections should be written generally - each answer stands alone.

Do not include the question in the answer text. The question is already captured in the name field. The text field should contain only the answer.

How to Add FAQ Schema to Ghost

On Ghost, FAQ schema is added through the post code injection footer - the same location as Article schema.

If a post has both Article schema and FAQ schema, add both as separate script blocks in the same footer field, one after the other. They do not need to be combined into a single block.

Step 1. Open the post in the Ghost editor.

Step 2. Open post settings and scroll to the Code injection section.

Step 3. In the footer field, paste the FAQPage schema block. If Article schema is already there, paste the FAQ schema block directly beneath it.

Step 4. Save or update the post.

Step 5. Validate using Google's Rich Results Test. The tool should detect both the Article schema and the FAQPage schema as separate entities. For a full guide to the validation process, read How to Test Schema Markup with Google's Rich Results Test.

How Many Questions to Include in the Schema

Include schema for every question in the FAQ section of the page.

If the page has five FAQ questions, the schema should contain five question blocks. If it has seven, include seven. The schema should accurately represent what is on the page - not a subset of it.

Google's guidelines state that FAQPage schema should only be used for pages where the FAQ content is the primary content or a significant section of the page. A single question buried in a long article is not a good candidate for FAQPage schema. A dedicated FAQ section with five or more questions is appropriate.

Common Mistakes

Using HTML in the answer text. The text field is plain text only. Any HTML tags included in the answer text will appear as literal characters in the structured data, causing validation errors.

Mismatched questions between schema and page. The questions in the schema should match the questions visible on the page. If the page is updated and questions are reworded or removed, update the schema to match.

Adding FAQPage schema to pages without a real FAQ section. FAQPage schema should only be used where there is a genuine FAQ section. Adding it to a page that does not have question-and-answer content is misleading to search engines and may result in a manual action.

Forgetting to include all questions. If a page has seven FAQ questions but the schema only includes three, the schema is incomplete. Include every question from the FAQ section.

Missing commas between question blocks. Each question object in the mainEntity array must be separated by a comma, except for the last one. A missing comma breaks the JSON formatting and the entire schema block will fail validation.

Frequently Asked Questions

Can I add FAQ schema to every page on my site? Only add FAQPage schema to pages that have a genuine FAQ section with real questions and answers. Using it on pages without FAQ content is against Google's structured data guidelines and can result in the schema being ignored or penalised.

Does FAQ schema work alongside Article schema? Yes. Both schema types can be present on the same page as separate JSON-LD script blocks in the footer. Google's Rich Results Test will detect and validate them independently.

What happens if my FAQ schema has a formatting error? A formatting error in the JSON means the schema block will not be read by search engines. The page remains in the index, but the structured data is unavailable. Fix the error, re-validate, and update the page.

Do the questions in the schema need to be word-for-word identical to what is on the page? They should match closely. Minor differences are generally accepted, but the schema should accurately represent the questions and answers visible on the page. Significant differences may trigger warnings in Google's validation tools.

How often should I update FAQ schema? Update it any time the FAQ section on the page changes - when questions are added, removed, or reworded. Schema that no longer matches the page content is inaccurate and may generate warnings.

Summary

FAQ schema uses the FAQPage type to explicitly label each question and answer on a page, making them directly readable by search engines and AI-powered search tools.

Each question is represented as a Question entity with a name (the question text) and an acceptedAnswer containing the answer as plain text.

On Ghost, FAQ schema goes in the post code injection footer. If Article schema is already there, add the FAQ schema block directly beneath it as a separate script block.

The answer text must be plain text only - no HTML. Each answer should be self-contained and match what is visible on the page.

Include schema for every question in the FAQ section. Validate the schema using Google's Rich Results Test after adding it.

For guidance on writing FAQ sections that work well for both readers and schema, read How to Add Article Schema to a Blog Post. For the full overview of schema types, read What is Schema Markup?