FAQ Schema Markup: FAQPage JSON-LD Example (2026)
November 11, 2026 · 10 min read
FAQ Schema Markup: Write FAQPage JSON-LD Step by Step
FAQ schema markup is a block of JSON-LD that labels the questions and answers on a page with the schema.org FAQPage type. You can still write it, but Google stopped showing FAQ rich results in May 2026. This tutorial covers where things stand, a valid example, and a Markdown workflow that keeps the markup and the page in sync.
What Is FAQ Schema Markup?
FAQPage is a schema.org type for a page that presents one or more frequently asked questions. On schema.org it sits under WebPage, so it describes the whole page, not one widget on it. Each question is a Question object, and each answer is an Answer object attached to it.
You add it as JSON-LD inside a script tag whose type is application/ld+json. Microdata and RDFa can carry the same data, but Google's structured data intro recommends JSON-LD when your setup allows it.
In SEO, "schema" means this shared vocabulary for describing content to machines, and "markup" means the structured data itself, not a markup language like HTML. Our schema markup explainer covers the wider vocabulary and the types that still earn Google rich results.
Does FAQ Schema Still Work in Google Search?
Not for rich results. Google's Search Central changelog has a May 8, 2026 entry deprecating the FAQ rich result, saying it no longer appears in Google Search starting May 7, 2026. A June 15, 2026 entry then removed the FAQ documentation entirely.
That ended a slow wind-down. In August 2023, Google limited FAQ rich results to well-known, authoritative government and health websites. In September 2025 it had already removed the docs for other retired types, such as course info and vehicle listing.
So why write it at all? Three reasons hold up:
- It costs nothing in Google. The 2023 post says structured data that isn't used doesn't cause problems for Search, though it has no visible effect either.
- It's a shared vocabulary. Any crawler, plugin or internal tool that reads schema.org can parse your questions and answers.
- It forces a clean FAQ. Writing the markup makes you check that every question has one clear, visible answer.
Don't count on it for a SERP feature, extra clicks or AI citations. We haven't found a search engine or AI assistant that documents a benefit for FAQPage, so treat anything beyond tidy data as a bonus you can't measure.
What Does a FAQPage JSON-LD Example Look Like?
Here's a complete, valid block for a three-question shipping FAQ. Paste it into the page that shows those same three questions.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "How long does delivery take?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Most orders arrive in 3 to 5 business days."
}
},
{
"@type": "Question",
"name": "Do you ship outside the US?",
"acceptedAnswer": {
"@type": "Answer",
"text": "We ship to Canada and the UK. Other countries are not available yet."
}
},
{
"@type": "Question",
"name": "How do I track my parcel?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Use the tracking link in your shipping confirmation email."
}
}
]
}
</script>
The browser doesn't display any of this. Parsers read it as one FAQPage holding three Question items, each with exactly one accepted Answer.
| Property | Belongs to | What it holds |
|---|---|---|
@context | the root object | The vocabulary URL, https://schema.org |
@type | every object | FAQPage, Question or Answer |
mainEntity | FAQPage | An array of Question objects |
name | Question | The question text, word for word as shown |
acceptedAnswer | Question | The Answer object |
text | Answer | The answer text, matching the visible answer |
Keep mainEntity as an array even when you only have one question. It saves you from restructuring the block when the second question arrives.
Writing FAQ Answers That Stay Valid JSON
Most broken FAQ blocks fail on plain JSON rules, not schema rules. The JSON standard, RFC 8259, is strict. Strings use double quotes, and a double quote inside a string must be escaped. A comma also can't follow the last item in an object or array.
This answer breaks on both counts:
{
"@type": "Answer",
"text": "Choose "Express" at checkout for next-day delivery.",
}
The quote before Express ends the string early, and the comma after the last property is a syntax error. Parsers reject the whole block, not just this answer. Here's the fixed version:
{
"@type": "Answer",
"text": "Choose \"Express\" at checkout for next-day delivery."
}
Escaping with a backslash keeps the quotes in the text, and removing the trailing comma makes the object valid. Rewording the copy to use single quotes also works, and we do that whenever the sentence allows it.
Line breaks inside a string must be written as an escape too, so keep each answer on one line. We prefer plain text in text as well. The list of HTML tags Google allowed in answers lived in its FAQ doc, which is now removed, so plain sentences are the safe default.
From a Markdown FAQ to FAQ Schema Markup
The hard part isn't the syntax. It's keeping the JSON-LD identical to the visible FAQ after six rounds of edits. Our answer is to write the FAQ once in Markdown and generate both outputs from it.
- Write each question as a
##heading and its answer as the paragraph below. Our guide to Markdown headings covers the syntax if you need it. - Render that Markdown to HTML for the page itself, with the Markdown to HTML converter or your site's build.
- Paste the same Markdown into the meta tag generator. It builds
FAQPageJSON-LD from## Questionheadings in your browser. - Copy the JSON-LD into the page and check it before you ship.
Writing FAQ schema markup by hand gets tedious past a handful of questions, and every hand-copied answer is a chance to drift. One limitation to know: the generator only builds the block. It doesn't validate or test it, so step 4 still matters.
Here's a Markdown FAQ in the editor. The preview shows the headings and answers your visitors will read, which is exactly the text your JSON-LD has to match.
This converter outputs HTML, not JSON-LD. Use it for the visible half, then take the same text to the generator for the structured half.
Where Should the FAQ and Its Markup Go on a Page?
Put the FAQ where readers can see it, on the same page as the markup. Google's structured data guidelines say not to mark up content that isn't visible to readers of the page. In practice, skip FAQs hidden from everyone, answers that differ from the page, and ad copy dressed up as questions.
The script block itself can sit in the head or the body. Google's intro to structured data lists both as valid places for JSON-LD, so pick whichever your template makes easier. A collapsed accordion is fine too. Google's old FAQ guidance listed an answer behind an expandable section as valid, as long as visitors could open it.
We'd keep one FAQPage block per page. Two blocks describing the same page just give parsers two versions to reconcile. The same logic applies across a site: if one Q&A pair repeats on many pages, Google's old guidance said to mark up only one instance of it.
If your site builds pages from Markdown with front matter, you can store the questions and answers as data and render both outputs from one template. See our Markdown front matter guide for how that metadata is structured.
FAQPage vs QAPage: Picking the Right Type
Use FAQPage when you write both the questions and the single official answer to each. Use QAPage when a page holds one question and visitors can post their own answers, like a forum thread or a support community.
Google's QAPage documentation is still live and draws the line clearly. It says not to use QAPage for FAQ pages or for pages with multiple questions, and that users must be able to submit answers. A product page with a few seller-written questions is an FAQ, not a Q&A page.
Testing FAQ Schema Markup Before You Ship
With the Google feature gone, test the markup against the vocabulary and the JSON rules rather than against a rich result.
- Check the vocabulary. Paste the rendered page URL or the code into
validator.schema.org. It parses the JSON-LD and shows theFAQPage,QuestionandAnswerobjects it found, with any errors. - Check the page source. Open view-source on the live page and search for
FAQPage. You should find exactly one block, with every question you can see on the page. - Compare the text. Read each
nameandtextagainst the visible FAQ. Edits that touched one and not the other show up here.
The honest limitation: a validator tells you the markup is well formed, not that anyone will use it. No tool can predict whether a search or answer engine reads your FAQ data.
Other FAQPage Questions
FAQ schema markup is still worth writing well, even without a rich result to chase: valid JSON, one block per page, and answers that match what visitors read. Draft the questions as Markdown headings in the editor, keep that file as your single source, then build the JSON-LD from it with the meta tag generator. When the FAQ changes, you edit one file and regenerate both halves.