If you've been adding FAQPage markup to your pages and not seeing the accordion effect in Google search results — your implementation isn't broken. Google removed FAQ rich results entirely as of May 7, 2026.
Not restricted. Removed.
That changes the calculus on whether to implement it at all. This guide covers how the schema actually works and how to build it correctly — but also where its value now sits, which is a different answer than most articles on this topic will give you.
What Is FAQ Schema Markup?
FAQ Schema uses the FAQPage type from schema.org/FAQPage to mark up a page that contains a list of frequently asked questions with their answers. Each question-answer pair is represented as an Question object inside mainEntity.
The structure is clean and straightforward compared to Product or Article schema:
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is FAQ Schema?",
"acceptedAnswer": {
"@type": "Answer",
"text": "FAQ Schema is structured data that marks up question-and-answer content so search engines can display it as rich results."
}
}
]
}
No complex nested objects, no variant handling, no price logic. Just questions and answers.
The Full Timeline: 2023 Restriction → 2026 Full Removal
August 2023: Restricted to health and government sites
Google's first major FAQ change restricted accordion rich results to "well-known, authoritative government and health websites." For most websites — dev blogs, SaaS tools, e-commerce, agencies — the FAQ accordion in Google Search stopped appearing.
May 7, 2026: Complete removal from Google Search
Google went further and fully deprecated FAQ rich results. As of May 7, 2026, FAQ accordions no longer appear for any site in Google Search — including government and health authorities that were previously eligible. Full removal of API support is scheduled for August 2026.
This means the accordion you saw in search results is gone from Google. Not restricted — removed.
What this means in practice:
| Site type | FAQ rich results in Google | FAQ schema still useful? |
|---|---|---|
| Government / health authorities | No — fully removed | Partially |
| Any other site | No — fully removed | Partially |
| Bing users | Yes — Bing still shows accordions | Yes |
So why implement it at all? Because Google is not the only environment where FAQ Schema has an effect — and the structural benefits remain even without the visual accordion.
Where FAQ Schema Still Has Value
Bing. Microsoft hasn't followed Google's lead here. Bing still shows FAQ accordions for any correctly implemented page, regardless of site type. Bing's share is roughly 3–9% of search volume depending on region and audience — smaller, but not nothing if you're thinking about your full traffic picture.
AI Overviews and AI search engines. Google's AI Overviews, Perplexity, and ChatGPT search all pull from structured content when constructing answers. Whether FAQPage markup increases citation frequency is hard to measure directly, but machine-readable Q&A is a better source for AI summarization than unstructured prose. The schema makes your content's question-answer pairs explicit rather than inferred.
Voice search. Google Assistant reads acceptedAnswer content when responding to voice queries. If your FAQ answers match common voice search phrasings — and they should if you wrote them from real user questions — the markup helps surface that content.
Content understanding more broadly. Even without any visual rich result, Google parses FAQ schema to understand what questions your page addresses. That can influence which conversational queries your page ranks for. Whether the effect is significant enough to measure on an individual page is unclear, but it's not zero.
FAQPage vs Q&APage: Which One to Use
Schema.org has two similar types that are commonly confused.
| Type | Use when | Google rich result |
|---|---|---|
FAQPage |
You wrote the questions AND the answers | Restricted (2023) |
QAPage |
Users submit questions, community answers | Separate rich result type |
The distinction matters. FAQPage is for curated content where you control both the question and the answer — like a product FAQ, a documentation page, or a support article you wrote yourself.
QAPage is for community-driven content — Stack Overflow-style pages where one user asks and others answer. It has its own rich result format showing the top-voted answer.
If you're adding a FAQ section to a landing page, documentation, or a blog post — use FAQPage. If you're building a community Q&A platform — use QAPage.
The Minimum Valid FAQ Schema
Google's requirements for FAQPage are simple: at least one Question object in mainEntity, and each Question must have name (the question text) and acceptedAnswer.text (the answer).
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "How does image compression work in the browser?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Browser-based image compression uses the Canvas API to redraw the image at a lower quality setting and export it via toBlob(). No file is uploaded to a server — the entire process runs locally in memory."
}
}
]
}
This is valid. For a real implementation, you want multiple questions and richer answer text.
A Complete FAQ Schema with Multiple Questions
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is the difference between JPG and WebP?",
"acceptedAnswer": {
"@type": "Answer",
"text": "WebP offers 25–35% smaller file sizes than JPG at equivalent visual quality, supports transparency (like PNG), and supports animation (like GIF). JPG has broader compatibility with older browsers and software. For modern web use, WebP is the better choice. For maximum compatibility, serve WebP with a JPG fallback."
}
},
{
"@type": "Question",
"name": "Is it safe to convert images in the browser?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Yes. Browser-based conversion uses the File API and Canvas API to process images entirely in memory on your device. No data is transmitted to any server. You can verify this by opening DevTools → Network and observing zero outgoing requests during conversion."
}
},
{
"@type": "Question",
"name": "Does converting JPG to WebP reduce image quality?",
"acceptedAnswer": {
"@type": "Answer",
"text": "At quality settings of 80 and above, the visual difference between JPG and WebP is imperceptible to the human eye. At lower quality settings (60–75), WebP maintains significantly better visual fidelity than JPG at the same file size. Set quality to 85 as a default starting point and adjust from there."
}
},
{
"@type": "Question",
"name": "How many FAQ items should a page have?",
"acceptedAnswer": {
"@type": "Answer",
"text": "There is no minimum or maximum defined by schema.org or Google. Practically, 5–15 questions covers the realistic range of user questions without padding. Each answer should be substantive — at least 40–60 words. Avoid thin one-sentence answers that add no value beyond restating the question."
}
}
]
}
Field Reference
| Field | Type | Required | Notes |
|---|---|---|---|
@type |
Text | Yes | Must be "FAQPage"
|
mainEntity |
Array of Question | Yes | At least one Question required |
Question.@type |
Text | Yes | Must be "Question"
|
Question.name |
Text | Yes | The question text. No character limit, but keep it concise |
Question.acceptedAnswer |
Answer | Yes | The answer object |
Answer.@type |
Text | Yes | Must be "Answer"
|
Answer.text |
Text | Yes | Plain text or HTML. See HTML rules below |
That's it. FAQ schema has the simplest field structure of any common schema type. There are no optional recommended fields to worry about — the schema lives or dies on question and answer quality.
HTML in acceptedAnswer.text: What's Allowed
Unlike most structured data fields which require plain text, Answer.text supports a limited set of HTML. Google's documentation explicitly permits:
"text": "WebP supports <strong>transparency</strong> and <em>animation</em>.<br>Learn more at <a href='https://developers.google.com/speed/webp'>developers.google.com</a>."
Permitted HTML tags: <a>, <br>, <b>, <strong>, <i>, <em>, <ul>, <ol>, <li>.
Do not use block-level elements like <div>, <p>, <h2>, or <section> inside answer text. These are not part of the spec and will cause validation warnings.
Practical use: HTML in answers is useful when you want to include links to related content or format a list of items within an answer. Don't over-format — the answer text should read clearly as plain text even without the HTML rendering.
Combining FAQPage with Other Schema Types
A page can have multiple JSON-LD blocks, and FAQPage is commonly combined with other types on the same page. This is valid and encouraged.
FAQPage + WebApplication (for a tool page):
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "WebApplication",
"name": "Image Converter",
"url": "https://example.com/image-converter",
"applicationCategory": "DeveloperApplication"
}
</script>
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [...]
}
</script>
Two separate <script> blocks — don't try to merge different @type values into one object. Each schema block is self-contained.
FAQPage + Article (for a blog post with a FAQ section):
A blog post about image optimization that has a FAQ section at the bottom can have both BlogPosting schema (for the article metadata) and FAQPage schema (for the Q&A section). Google treats them as separate entities describing different aspects of the same page.
Implementation in Next.js (App Router)
// app/tools/image-converter/page.tsx
const faqItems = [
{
question: 'Does image conversion happen on my device?',
answer: 'Yes. All conversion runs in your browser using the Canvas API. No files are uploaded to any server. Check the Network tab in DevTools — you will see zero outgoing file transfers.',
},
{
question: 'Which image formats are supported?',
answer: 'JPG, PNG, WebP, AVIF, and GIF as input. JPG, PNG, and WebP as output. AVIF output requires Chrome 85+ — the tool hides unsupported output formats automatically based on your browser.',
},
{
question: 'Is there a file size limit?',
answer: 'There is no server-side limit because no files reach a server. The practical limit is your device memory — images over 50MB may cause the browser tab to slow down on low-end devices.',
},
]
export default function ImageConverterPage() {
const jsonLd = {
'@context': 'https://schema.org',
'@type': 'FAQPage',
mainEntity: faqItems.map((item) => ({
'@type': 'Question',
name: item.question,
acceptedAnswer: {
'@type': 'Answer',
text: item.answer,
},
})),
}
return (
<>
<script
type="application/ld+json"
dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
/>
{/* tool UI */}
<section>
<h2>Frequently Asked Questions</h2>
{faqItems.map((item) => (
<details key={item.question}>
<summary>{item.question}</summary>
<p>{item.answer}</p>
</details>
))}
</section>
</>
)
}
Key detail: the FAQ items array is shared between the JSON-LD generator and the rendered HTML. This guarantees the structured data always matches the visible page content — a requirement Google explicitly checks.
Implementation in React (with react-helmet-async)
import { Helmet } from 'react-helmet-async'
const FAQ_ITEMS = [
{
question: 'How does browser-based image compression work?',
answer: 'The browser draws your image onto an off-screen Canvas element, then exports it via toBlob() with a reduced quality setting. The quality parameter (0–1) controls the compression ratio. Higher values preserve more detail; lower values produce smaller files.',
},
{
question: 'Can I batch convert multiple images?',
answer: 'Yes. Drop multiple files at once. Each file is processed independently in the browser. When all conversions are complete, download them individually or as a ZIP archive.',
},
]
function ToolPage() {
const jsonLd = {
'@context': 'https://schema.org',
'@type': 'FAQPage',
mainEntity: FAQ_ITEMS.map((item) => ({
'@type': 'Question',
name: item.question,
acceptedAnswer: {
'@type': 'Answer',
text: item.answer,
},
})),
}
return (
<>
<Helmet>
<script type="application/ld+json">
{JSON.stringify(jsonLd)}
</script>
</Helmet>
<section aria-label="FAQ">
<h2>Frequently Asked Questions</h2>
{FAQ_ITEMS.map((item) => (
<div key={item.question}>
<h3>{item.question}</h3>
<p>{item.answer}</p>
</div>
))}
</section>
</>
)
}
Implementation in WordPress
For WordPress sites, you can add FAQ schema dynamically from a custom fields setup or a static block in functions.php. The cleanest approach for a dedicated FAQ page is to use a Custom Post Type with question/answer fields:
function add_faq_schema() {
if ( ! is_page( 'faq' ) && ! is_singular( 'faq_item' ) ) return;
// Example: pull FAQ items from an ACF repeater field
$faq_items = get_field( 'faq_items' );
if ( ! $faq_items ) return;
$schema = [
'@context' => 'https://schema.org',
'@type' => 'FAQPage',
'mainEntity' => array_map( function( $item ) {
return [
'@type' => 'Question',
'name' => sanitize_text_field( $item['question'] ),
'acceptedAnswer' => [
'@type' => 'Answer',
'text' => wp_kses( $item['answer'], [
'a' => [ 'href' => [] ],
'br' => [],
'strong' => [],
'em' => [],
'ul' => [],
'ol' => [],
'li' => [],
]),
],
];
}, $faq_items ),
];
echo '<script type="application/ld+json">' . wp_json_encode( $schema ) . '</script>';
}
add_action( 'wp_head', 'add_faq_schema' );
If you're not using ACF, define the FAQ items as a static array in functions.php and follow the same pattern. The key is using wp_kses() to sanitize the answer HTML — never output raw user-controlled content directly into a <script> block.
The 7 Most Common FAQ Schema Mistakes
1. Questions that don't appear on the page
This is the most common mistake and the most penalized. Every question in your FAQPage JSON-LD must correspond to a visible question on the page. Google checks this. If your structured data has 8 questions but the page only shows 3, expect a rich result suppression.
Add an FAQ section to the page. If you don't want it visually prominent, use <details>/<summary> for a collapsible section — it's visible in the DOM but compact in the UI.
2. Answers that are one sentence long
// Weak — barely more than restating the question
"text": "Yes, we support batch conversion."
// Better — answers the follow-up questions the user has
"text": "Yes. Drop multiple files at once — up to 50 per batch. Each file is processed independently. When all conversions finish, download them individually or click 'Download All' to get a ZIP archive."
Thin answers don't help users and don't help Google understand your content. Write answers that are 40–100 words and genuinely resolve the question.
3. Duplicate questions across multiple pages
If every page on your site has the same 5 generic FAQ items, Google treats them as low-quality boilerplate. FAQ content should be specific to the page's topic. A page about PNG-to-JPG conversion should have different FAQ items than a page about WebP compression.
4. Using FAQPage for QAPage content
If your page has a single canonical answer written by you — use FAQPage. If it shows multiple answers from different users (like a forum or comment section) — use QAPage. Using FAQPage for community-answered content is a schema type mismatch that will cause validation errors.
5. Nesting FAQPage inside another schema type
// Wrong — FAQPage cannot be a property of WebApplication
{
"@type": "WebApplication",
"faq": {
"@type": "FAQPage",
...
}
}
// Correct — separate script blocks
FAQPage is always a top-level @type, never a nested property of another schema. Use separate <script type="application/ld+json"> blocks.
6. Expecting Google accordion rich results
As of May 7, 2026, FAQ rich results are fully removed from Google Search — for every site, including previously eligible government and health sites. If you're implementing FAQ schema hoping to see the expandable accordion in Google, it will not appear. Implement it for the other benefits (Bing, voice search, AI Overviews, content understanding), not for a Google accordion that no longer exists.
7. HTML in Answer.text that breaks JSON syntax
Using raw HTML entities or unescaped characters inside JSON strings causes parse errors:
// Wrong — unescaped quotes break JSON
"text": "Use the <a href="https://example.com">tool here</a>."
// Correct — escape inner quotes
"text": "Use the <a href=\"https://example.com\">tool here</a>."
When building JSON-LD in JavaScript, always use JSON.stringify() to handle escaping automatically. Never concatenate raw HTML strings into a JSON structure manually.
Writing FAQ Questions That Actually Rank
FAQ schema's content-understanding benefit depends on how well your questions match real user queries. Generic questions that you invented don't help — questions that mirror actual search queries do.
How to find real questions to answer:
Google autocomplete — type your topic into Google Search and look at the suggestions. "How to convert PNG to..." reveals "...JPG without losing quality", "...smaller file size", "...transparent background". These are real queries.
People Also Ask boxes — search your main topic and look at the PAA (People Also Ask) accordion in the results. These are verified questions that a meaningful number of people search for. Use them as your FAQ items verbatim or with minor rewording.
Search Console → Queries — if your page already has some traffic, the Queries report shows what people searched before clicking through. Questions in this list are your highest-value FAQ candidates.
Answer the Public — a tool that aggregates autocomplete data across question formats (who, what, where, when, why, how) for any keyword.
The ideal FAQ item has:
- A question that matches an actual search query
- An answer that's complete enough to satisfy the query without clicking away
- Natural language — write the way a person asks, not the way a business answers
How Many FAQ Items Should You Include?
There's no schema.org minimum. Google's documentation mentions no minimum either. But practically:
Too few (1–3 items): Signals low-effort implementation. Barely worth including.
Right range (5–15 items): Covers the realistic spread of genuine questions without padding. This is where almost every well-implemented FAQ page lands.
Too many (20+ items): Unless you're a support center with a genuinely exhaustive FAQ, this starts to look like keyword stuffing. Google may treat it as low-quality content inflation.
Target 8–12 items for most pages. Every question should represent something a real user would actually ask. If you're struggling to write question 10, stop at 9.
Validating FAQ Schema
Google Rich Results Test — search.google.com/test/rich-results
Paste the URL or raw JSON-LD. Even though Google no longer shows FAQ accordions for most sites, the test will still validate your markup structure, flag errors, and confirm that Google can read your questions and answers correctly.
Schema.org Validator — validator.schema.org
Validates against the schema.org spec. Useful for catching type errors and structural issues.
Manual check: After deploying, view the page source and confirm that the questions in your <script type="application/ld+json"> block exactly match the questions visible in the page HTML. This is the check Google runs — you should run it too.
Post-deployment: submit the URL in Google Search Console for indexing and check the Enhancements tab after 7–10 days.
Summary
FAQ Schema is a case study in how quickly structured data guidance becomes outdated. The timeline: open to everyone → restricted to health/gov (August 2023) → fully removed from Google Search (May 7, 2026). The schema itself is still valid. The Google accordion is gone.
The honest summary:
- Google accordion rich results: Fully removed as of May 7, 2026 — no site is eligible
- Bing accordion rich results: Still available for all correctly implemented pages
- AI Overviews and voice search: FAQ markup improves your chances of being sourced
- Content understanding: Questions help Google match your page to conversational queries
The practical checklist:
- Every question in JSON-LD must appear visibly on the page
- Write answers that are 40–100 words and genuinely resolve the question
- Use questions sourced from real user queries (autocomplete, PAA boxes, Search Console)
- Use
FAQPagefor your own curated Q&A,QAPagefor community content - Keep two separate
<script>blocks if combining with another schema type - Validate with Rich Results Test before deploying — it still catches structural errors even though Google no longer shows the accordion
If you want to build FAQPage JSON-LD through a form interface without writing JSON by hand, there's a free generator here: FAQ Schema Generator. Live preview, validation, copy-ready output.
Still seeing FAQ accordions somewhere in Google? That would be a surprise worth documenting — drop a comment with the query and site.
Top comments (0)