Place a <script type="application/ld+json"> block in your page’s <head> containing a JSON object with "@type": "FAQPage" and a mainEntity array of your question-answer pairs. The schema must mirror a visible FAQ section already on the page. You’re marking up real content, not adding hidden questions. A working, copy-ready example is below.[1]
Copy the working example below, replace the questions and answers with your own, and paste it into the head of every content page on your site.
JSON-LD in the head is read by AI crawlers on every visit, before any JavaScript runs. It's the cleanest, most reliable way to deliver structured data.
After adding FAQ schema, validate it using Google's Rich Results Test to confirm it's structured correctly before publishing.
@graph array.Before adding schema, your page needs an actual FAQ section that human visitors can read. This is a critical rule: FAQ schema reflects existing on-page content. It does not create content.[2]
A minimal HTML FAQ section for a content page looks like this:
<section>
<h2>Frequently Asked Questions</h2>
<details>
<summary>What is FAQ schema markup?</summary>
<p>FAQ schema is structured data in JSON-LD format that tells AI engines and search systems the exact questions a page answers and what those answers are.</p>
</details>
<details>
<summary>Where does FAQ schema go on a webpage?</summary>
<p>FAQ schema goes in the head section of the HTML document, inside a script tag with type="application/ld+json".</p>
</details>
</section>
The <details>/<summary> pattern is a clean accessible approach for FAQ accordions. Other HTML patterns work equally well. The structure of your visible FAQ doesn't constrain the schema.
With your visible FAQ in place, write the matching schema block. Here is a complete, working example with two questions that you can adapt directly:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is FAQ schema markup?",
"acceptedAnswer": {
"@type": "Answer",
"text": "FAQ schema is structured data in JSON-LD format that tells AI engines and search systems the exact questions a page answers and what those answers are. It sits in the page head, invisible to visitors but directly readable by machines."
}
},
{
"@type": "Question",
"name": "Where does FAQ schema go on a webpage?",
"acceptedAnswer": {
"@type": "Answer",
"text": "FAQ schema goes in the head section of the HTML document, inside a script tag with type='application/ld+json'. This ensures AI crawlers read it before any JavaScript runs."
}
}
]
}
</script>
Key rules for the JSON:
"name" contains the question text, written exactly as a visitor would ask it"text" contains the full answer. Complete sentences, not fragments\"For content pages, FAQ schema is most powerful when stacked with other schema types. The @graph pattern lets you include multiple schema types in one script block:[3]
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "BlogPosting",
"headline": "What is FAQ schema markup?",
"description": "FAQ schema is structured data in JSON-LD...",
"datePublished": "2026-03-18",
"author": {
"@type": "Person",
"name": "Your Name",
"url": "https://yoursite.com"
}
},
{
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "Your first question here?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Your complete answer here."
}
}
]
},
{
"@type": "BreadcrumbList",
"itemListElement": [
{"@type": "ListItem", "position": 1, "name": "Home", "item": "https://yoursite.com"},
{"@type": "ListItem", "position": 2, "name": "Your Topic", "item": "https://yoursite.com/topic/"},
{"@type": "ListItem", "position": 3, "name": "This Page", "item": "https://yoursite.com/topic/this-page"}
]
}
]
}
</script>
This single block communicates: this is an article, written by this person, answering these specific questions, located at this position in the site structure. Four schema types. One script block. Maximum signal density.
The entire <script type="application/ld+json"> block goes inside the <head> element of your HTML document. The conventional placement is after your meta tags and before the closing </head> tag:
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Page Title | Site Name</title>
<meta name="description" content="...">
<link rel="canonical" href="...">
<!-- Schema block goes here -->
<script type="application/ld+json">
{ ... your schema ... }
</script>
</head>
The most important rule: this block must be present in the static HTML source. Never inject schema markup via JavaScript. AI crawlers do not execute JavaScript, and dynamically injected schema is invisible to them.[4]
A single syntax error in your JSON breaks the entire schema block silently. AI crawlers and search engines simply skip it without warning. Always validate before publishing.
search.google.com/test/rich-results. Confirms whether Google can read your schema and whether it qualifies for rich results display. Paste your URL or raw HTML.validator.schema.org. Validates your JSON-LD against the Schema.org specification. Useful for confirming the structure is correct even before a page is publicly live.Common errors to check for: missing commas between objects, unclosed brackets, unescaped double quotes inside answer text, and missing required properties (@type, name, acceptedAnswer).
The reason I recommend pure HTML/CSS/JS for authority directories, rather than WordPress or page builders, comes down to exactly this: control over your schema implementation.
When you own the HTML, adding FAQ schema is five minutes of work per page. You write the JSON, paste it into the head, validate it, done. There is no plugin to configure, no interface to navigate, no mystery about whether it's actually rendering in the source. You open your HTML file, you see the schema block. What you write is what AI reads.
I've seen too many websites where the WordPress plugin says it added schema, but checking the page source shows JavaScript-injected markup that AI crawlers never see. The page looks schema-optimized in the admin panel. In the actual source file that GPTBot reads: nothing.
If you're using a CMS, do the extra step of verifying your schema in raw page source, not in a plugin dashboard. The only schema that works for AI recommendation is schema that lives in the static HTML source before any JavaScript runs. Full stop.
FAQ schema in JSON-LD format should go in the head section of your HTML document. While Google technically supports JSON-LD in the body, placing it in the head is standard practice and ensures it is read first by crawlers. For AI bots that may stop reading partway through a large page, head placement guarantees the schema is indexed regardless of page length.
Yes, and you should. The most effective approach for content pages is to use a single script block with a @graph array containing multiple schema types: BlogPosting (or Article), Author (Person), FAQPage, and BreadcrumbList. Using @graph allows all schema types to coexist on one page and share context, creating a stronger combined authority signal than any single type alone.
Use Google's Rich Results Test (search.google.com/test/rich-results) to validate your FAQ schema. Paste your page URL or raw HTML and the tool will confirm whether Google can read your FAQPage schema and whether it qualifies for rich result display. Schema.org also provides a validator at validator.schema.org for general structured data validation.
You can write FAQ schema yourself. It is plain JSON wrapped in a script tag. No plugin is required for custom HTML websites. If you're using WordPress, plugins like Rank Math or Yoast SEO can generate FAQ schema from their editors. For custom HTML sites like authority directories built with Claude Code, writing the JSON-LD directly in the head gives you the most control and the cleanest output.
No. JSON-LD schema is plain text embedded in your HTML. It adds negligible file size (typically 1–3KB per page) and has no rendering impact because it is not displayed visually. Unlike plugins or JavaScript-based schema solutions, static JSON-LD in the head adds zero page load overhead.
Take the free AI Visibility Scan to discover your current positioning, or explore the complete build system.