# FAQ Schema in 2026: FAQPage Markup Without the Rich Result

> FAQPage is schema.org markup that lists the questions a page answers and the answer to each one. Google stopped showing the FAQ rich result on May 7, 2026, so the markup no longer changes how your page looks in Google. It remains valid vocabulary: keep it only for questions and answers that are visible on the page, because the written answers, not the markup, are what readers and AI assistants use.

Source: https://tonaily.com/guides/faq-schema/
Last updated: 2026-11-06
Checked against sources on: 2026-11-06

## What is FAQ schema?

FAQ schema is a block of structured data, usually JSON-LD, that tells machines "this page contains these questions, and here is the answer to each one". It uses the schema.org type `FAQPage`, defined as "a WebPage presenting one or more 'Frequently asked questions'" ([schema.org](https://schema.org/FAQPage)).

Inside it, each question is a `Question`, which schema.org describes as "a specific question - e.g. from a user seeking answers online, or collected in a Frequently Asked Questions (FAQ) document" ([schema.org](https://schema.org/Question)). Its answer goes in `acceptedAnswer`, as an `Answer`. The list of questions sits in the page's `mainEntity`.

For years, the point of this markup was the FAQ rich snippet: the questions unfolding under your result in Google. That is the part that changed, and it is why many pages using a FAQ schema generator in 2026 get impressions but nothing visible in the results.

## Does Google still show FAQ rich results?

No. Since May 7, 2026, Google no longer shows the FAQ rich result for any site. The markup is still valid schema.org, but it no longer changes how your page looks in Google Search.

The timeline, from Google's own announcements:

1. **August 8, 2023.** Google restricts the result: "Going forward, FAQ (from `FAQPage` structured data) rich results will only be shown for well-known, authoritative government and health websites." ([Search Central blog](https://developers.google.com/search/blog/2023/08/howto-faq-changes)). Every other site loses it.
2. **May 8, 2026.** A deprecation notice appears in the documentation changelog: "This feature will no longer appear in Google Search starting May 7, 2026." ([documentation updates](https://developers.google.com/search/updates)).
3. **June 15, 2026.** Google removes the FAQ rich result documentation, because "The FAQ rich result feature is no longer shown in Google Search results". The old documentation URL now redirects to that changelog entry.

If an article, plugin or tool still promises "FAQ rich snippets" for your pages, it is out of date. Search Console impressions on FAQ pages come from the normal blue link, not from an expanded FAQ.

```quote source="Google Search Central Blog, Changes to HowTo and FAQ rich results" href="https://developers.google.com/search/blog/2023/08/howto-faq-changes"
there's no need to proactively remove it. Structured data that's not being used does not cause problems for Search, but also has no visible effects in Google Search.
```

Google wrote this in 2023, when the result was restricted. It is the honest framing for 2026 too: FAQPage markup will not hurt you, and it will not get you a special display either.

## Is FAQ schema still worth adding?

Yes, in one case: the page really has a questions-and-answers section that readers can see. Then the markup is cheap, accurate, and describes the content to any system that reads schema.org. If the page has no visible Q&A, adding FAQPage gets you nothing.

What the markup does not do anymore:

- It does not create an expanded FAQ under your result in Google.
- It is not required for Google's AI features. Google writes: "There's also no special schema.org structured data that you need to add." ([AI features and your website](https://developers.google.com/search/docs/appearance/ai-features)).
- It is not a ranking shortcut. Google's general guidelines say "Google does not guarantee that your structured data will show up in search results" ([general structured data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)).

What it still does: it labels each question and its answer explicitly, in a standard vocabulary, and it forces you to write the FAQ properly. That second effect is the most useful one. The broader question of which schema types still matter for AI search is covered in the guide [schema markup for AI search](/guides/schema-markup-ai-search/); this guide sticks to FAQPage.

## How do you write FAQPage JSON-LD?

Write the questions and answers on the page first, then copy them word for word into one `FAQPage` block: `mainEntity` holds a list of `Question` items, each with a `name` (the question) and an `acceptedAnswer` of type `Answer` with its `text`.

Here is a complete example for a dog grooming salon's pricing page:

```html title="FAQPage JSON-LD"
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does a full grooming session take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Between one and a half and three hours, depending on the size and coat of the dog. We confirm the time when you book."
      }
    },
    {
      "@type": "Question",
      "name": "Can I stay with my dog during the session?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes for puppies on their first visit. For other dogs, we call you 15 minutes before pickup."
      }
    }
  ]
}
</script>
```

A few practical rules:

- **JSON-LD is the format to use.** Google supports three formats and lists "JSON-LD (recommended)" ([general guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)). It sits in a `<script>` tag, separate from your HTML, so you can add it in the `<head>` or the body without touching the layout.
- **One block for the page's FAQ.** List every question that page answers in the same `mainEntity`, rather than scattering several FAQPage blocks.
- **Plain text in the answers.** Keep the answer readable as it is. If it contains quotation marks, they must be escaped (`\"`) or the JSON breaks.
- **Same words as the page.** Paste the answer as it is published, not a longer or keyword-stuffed version.

You don't have to type the braces yourself. The free **[FAQ schema generator](/resources/tools/faq-schema-generator/)** builds this block as you add questions and answers, flags a missing answer, a missing question mark or a duplicate question, and gives you the complete `<script>` tag to copy. Everything stays in your browser.

## Does the FAQ content have to be visible on the page?

Yes. This is the rule that has not changed: the questions and answers in your markup must be readable by visitors on that same page. An accordion that opens on click is fine; text that only exists in the JSON-LD is not.

```quote source="Google Search Central, General structured data guidelines" href="https://developers.google.com/search/docs/appearance/structured-data/sd-policies"
Don't mark up content that is not visible to readers of the page.
```

The same page adds: "Your structured data must be a true representation of the page content." These are general guidelines, valid for every type, so they still apply to FAQPage now that its dedicated documentation is gone. Breaking them can lead to a structured data manual action, which, in Google's words, means "a page loses eligibility for appearance as a rich result".

In practice, a "hidden FAQ" designed only for machines is the clearest way to misuse this markup. So is the same boilerplate FAQ copied onto every page of the site: the markup then describes questions that page does not really answer.

## FAQPage or QAPage: which one should you use?

Use FAQPage when you, the site owner, write both the questions and the answers. Use QAPage when the page is about one question and users can post their own answers, like a forum thread or a community answer page.

Google's QAPage documentation is explicit: "Don't use `QAPage` markup for FAQ pages or pages where there are multiple questions per page." It lists as invalid "An FAQ page written by the site itself with no way for users to submit alternative answers", and as a valid case "A forum page where users can submit answers to a single question" ([Q&A structured data](https://developers.google.com/search/docs/appearance/structured-data/qapage)).

| Your page | Type to use |
|---|---|
| Your pricing page ends with 6 questions you wrote and answered | FAQPage |
| A support article listing common questions about one product | FAQPage |
| A forum thread where members answer one question | QAPage |
| A product page with no Q&A section | Neither: use Product, via the [schema markup generator](/resources/tools/schema-markup-generator/) |

If a page needs several types (an article with a FAQ at the end, for instance), the [schema markup generator](/resources/tools/schema-markup-generator/) covers Article, Product, LocalBusiness, Organization and BreadcrumbList, and the [FAQ schema generator](/resources/tools/faq-schema-generator/) handles the FAQPage part.

## What are the most common FAQ schema errors?

Most errors fall into two groups: markup that does not match the page, and JSON that does not parse. The first group is the one that matters most.

1. **Marking up text that is not on the page.** The answer exists in the JSON-LD only, or in a longer version than the visible text. This breaks the visible-content rule above.
2. **The same FAQ on every page.** A sitewide block of generic questions, injected by a theme or a plugin, does not represent each page's content.
3. **Two FAQPage blocks on one page.** Often a plugin and a theme both output one. Check the page source and keep a single block that lists every question.
4. **FAQPage on a user Q&A thread** (or QAPage on your own FAQ). See the table above.
5. **Broken JSON.** A trailing comma after the last question, an unescaped quotation mark in an answer, a missing closing bracket. One character is enough for the whole block to be ignored.
6. **An answer with no question, or the reverse.** Every `Question` needs its `name` and an `acceptedAnswer` with `text`.
7. **Questions written for keywords, not for readers.** "Best cheap dog grooming near me?" is not a question anyone asks your salon. Write the questions your customers actually ask by phone or email.
8. **Expecting a rich result.** None will appear, for any site, since May 7, 2026. Judge the FAQ on what it does for readers.

```checklist title="Before you publish a FAQ with FAQPage markup"
- Every question and answer in the markup is visible on the page, word for word
- The questions are ones your customers actually ask
- Each answer is self-contained: the first sentence answers the question
- The FAQ belongs to this page, not copied across the whole site
- There is a single FAQPage block, listing every question on the page
- The page is a FAQ written by you, not a thread where users post answers (that is QAPage)
- The JSON-LD passes the Schema Markup Validator with no errors
- Nobody on the team expects a FAQ rich result in Google
```

## How do you test FAQ schema?

Test the syntax with the Schema Markup Validator, then check by eye that the visible page says the same thing. The Rich Results Test is not the right tool for FAQPage anymore.

**Schema Markup Validator.** At [validator.schema.org](https://validator.schema.org/), paste a URL or a code snippet. It reads schema.org markup in general, independent of which rich results Google shows, so it tells you whether your FAQPage, Question and Answer items are parsed correctly.

**Rich Results Test.** Google's tool accepts a URL ("Submit the full URL of the page to test") or a code snippet, and reports "which rich result types were found on the page" ([Search Console Help](https://support.google.com/webmasters/answer/7445569)). Its list of currently supported types includes Article, Organization, Product snippet, Q&A page and others, but not FAQ. Use it for the other types on the page, not to validate the FAQ.

**The manual check.** Open the page, expand the FAQ, and compare each question and answer with the JSON-LD. No tool checks that the markup matches what readers see; that part is on you.

**The page source.** Search the HTML for `"FAQPage"`. More than one hit usually means a duplicate block from a plugin.

## Why does FAQ content still help with AI answers?

Because AI assistants read and cite the text on the page, and a well-written FAQ is a set of short, self-contained answers to questions people actually ask. That value comes from the visible content, not from the markup.

What is documented: Google says its AI features need no special markup, and that a page "must be indexed and eligible to be shown in Google Search with a snippet" with "no additional technical requirements" ([AI features and your website](https://developers.google.com/search/docs/appearance/ai-features)). Among the SEO best practices it lists on that page is "Making sure your structured data matches the visible text on the page". Its guide on generative AI features files the topic under a myth called "Overfocusing on structured data", while adding that it is "a good idea to continue using it as part of your overall SEO strategy" ([optimization guide](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)).

What is not documented: no provider publishes a figure on how much a FAQ section, with or without FAQPage, increases citations. Treat any "FAQ schema boosts AI citations by X%" claim as unsourced.

So the practical approach is:

- **Answer first.** The first sentence of each answer should work on its own if it is quoted out of context.
- **Use the customer's words.** The question as people phrase it to you, or to an assistant. The guide on [prompts to track for AI visibility](/guides/ai-visibility-prompts/) shows how to find those questions.
- **Be specific.** Durations, prices, conditions, areas served. A vague answer gives an assistant nothing to repeat.
- **Keep it current.** An outdated price in a FAQ is the line most likely to be quoted back to a customer.

The wider method for being cited by ChatGPT, Gemini and others is in the guide [GEO: get cited by ChatGPT, Gemini and Grok](/guides/generative-engine-optimization/). The questions at the bottom of this guide follow the same pattern: visible on the page, marked up with FAQPage, each answer readable on its own.

```tonaily
When Kira drafts an article in Tonaily, it can include a **FAQ section** written answer-first, and the editor shows **SEO and AI scores** as you review it. Once the FAQ text is final, paste the questions and answers into the free [FAQ schema generator](/resources/tools/faq-schema-generator/) to get the matching JSON-LD.
```

## What should you do with your FAQ schema today?

Audit, don't panic. Keep FAQPage where it describes a real, visible FAQ; remove it where it describes hidden or sitewide boilerplate; and spend the effort on the answers themselves.

1. **List the pages that output FAQPage.** Search your templates and plugins, or the page sources.
2. **Delete the markup on pages with no visible FAQ.** It describes nothing readers can see.
3. **Rewrite weak FAQs.** Real customer questions, answer in the first sentence, specific details.
4. **Regenerate the JSON-LD** from the final text with the [FAQ schema generator](/resources/tools/faq-schema-generator/), and validate it.
5. **Stop reporting on FAQ rich results.** Measure the page itself: impressions and clicks in Search Console, and whether assistants mention you on the questions that matter.

FAQ schema is a small, honest piece of markup now: a precise label on content that should be worth reading anyway. For the rest of your structured data, start with the guide [schema markup for AI search](/guides/schema-markup-ai-search/) and the [schema markup generator](/resources/tools/schema-markup-generator/).

## FAQ

### Does Google still show FAQ rich results?

No. Google's documentation changelog says the FAQ rich result "will no longer appear in Google Search starting May 7, 2026", and the FAQ documentation was removed on June 15, 2026. Before that, since August 2023, it was limited to well-known, authoritative government and health websites.

### Should I remove the FAQPage markup from my site?

There is no urgency. When Google restricted the result in 2023, it wrote that unused structured data does not cause problems for Search but has no visible effect either. Keep the markup where it matches a real, visible Q&A section; remove it where it describes text nobody can see.

### What is the difference between FAQPage and QAPage?

FAQPage is for a page where the site itself writes the questions and the answers. QAPage is for a page focused on a single question where users can submit answers, such as a forum thread. Google says not to use QAPage for FAQ pages or for pages with several questions.

### Can the Rich Results Test check my FAQ schema?

Not as a FAQ result: FAQ is not in the list of rich result types the Rich Results Test currently supports. To check that the JSON-LD is valid schema.org, use the Schema Markup Validator at validator.schema.org.

### Do I need FAQ schema to appear in Google's AI Overviews or AI Mode?

No. Google writes that there is no special schema.org structured data you need to add, and that a page only needs to be indexed and eligible to be shown with a snippet. What can help is a clear, visible answer on the page.


## Sources

- [Google Search Central: Latest documentation updates (FAQ rich result deprecation, May 8, 2026, and documentation removal, June 15, 2026)](https://developers.google.com/search/updates)
- [Google Search Central Blog: Changes to HowTo and FAQ rich results (August 8, 2023)](https://developers.google.com/search/blog/2023/08/howto-faq-changes)
- [Google Search Central: General structured data guidelines](https://developers.google.com/search/docs/appearance/structured-data/sd-policies)
- [Google Search Central: Q&A (QAPage) structured data](https://developers.google.com/search/docs/appearance/structured-data/qapage)
- [Google Search Central: AI features and your website](https://developers.google.com/search/docs/appearance/ai-features)
- [Google Search Central: Optimizing your website for generative AI features on Google Search](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)
- [Search Console Help: Rich Results Test](https://support.google.com/webmasters/answer/7445569)
- [schema.org: FAQPage](https://schema.org/FAQPage)
- [schema.org: Question](https://schema.org/Question)
- [Schema Markup Validator](https://validator.schema.org/)