How to use the FAQ Schema Generator

Using the FAQ schema generator takes a couple of minutes. Everything runs in your browser, so the questions and answers you type are not sent anywhere.

  1. Add your first question in the question field. Use the same wording that appears as a visible heading on your page, for example “How long does shipping take?”
  2. Type the answer in the answer field. Write it as you would show it to a visitor: direct, complete, and self-contained. Basic formatting such as links and line breaks is allowed.
  3. Click the add button to create another question and answer pair. Repeat until every question that is visible on your page is in the list. Use the remove and reorder controls to tidy the list.
  4. Review the generated FAQPage JSON-LD in the output panel. It updates as you type, and it is already escaped, so quotes, line breaks and special characters will not break the JSON.
  5. Click copy to put the code on your clipboard, or download it as a file if you prefer.
  6. Paste the code inside a <script type="application/ld+json"> tag in the HTML of the same page that shows the questions. Then run the page through a validator (see the best practices below) before you publish.

Tip: Write the visible FAQ section on your page first, then paste the same text into the tool. Copying from the page, not from memory, is the easiest way to keep markup and visible content identical.

What FAQ schema is

FAQ schema is structured data that describes a list of frequently asked questions and their answers in a format machines can read without guessing. It uses the FAQPage type from the schema.org vocabulary. Each question is a Question entity, and each answer is an Answer entity attached to that question.

On a normal web page, a question is just a heading and an answer is just a paragraph. A human can tell they belong together because of layout. A machine has to infer it from HTML structure, which varies from site to site and theme to theme. FAQ schema removes the guesswork by stating the pairing explicitly: this text is a question, and this text is its answer.

The recommended way to publish structured data is JSON-LD, a block of JSON that sits in a script tag and is separate from the visible markup. Google recommends JSON-LD over the older Microdata and RDFa syntaxes because it is easier to add, easier to maintain and does not require touching your page template. The generator on this page outputs JSON-LD.

The minimum structure

A valid FAQPage has a mainEntity property that holds a list of questions. Each question needs a name (the question text) and an acceptedAnswer that is an Answer with a text property. That is all that is required. Everything else is optional.

FAQPage versus QAPage

Schema.org also has a QAPage type. The two are easy to mix up. Use FAQPage when your site publishes the questions and one definitive answer for each. Use QAPage when the page is built around a single question that users can answer, with multiple community answers, as on a forum or a Q&A site. A support article with a short list of questions and your own answers is a FAQPage.

Why FAQ schema matters for AI search and answer engines

Answer engines work by finding passages that answer a question and presenting or summarizing them. A page that is already organized as questions and answers is a good source for that, because the structure matches the way people phrase prompts. FAQ markup makes that structure explicit.

Here is the honest picture of how it helps, and where the limits are.

It makes the question and answer pairing unambiguous

When a crawler or a content pipeline processes your page, it can extract the JSON-LD directly. It does not need to decide whether a heading is a question or whether the next paragraph is its answer. For any system that consumes structured data, that is a cleaner input than parsed HTML. Whether a given AI engine reads structured data at retrieval time is not something any provider has documented in detail, so treat the benefit as “easier to understand if consumed” rather than “guaranteed to be used.”

It forces you to write answer-shaped content

Perhaps the most dependable benefit has nothing to do with markup. To fill in the generator you have to write a short, direct answer to a specific question. That is the content shape AI assistants prefer to quote: a clear question, a direct answer in the first sentence, and a little supporting detail. The schema is a by-product of doing that work well.

It mirrors real prompts

Many prompts people type into ChatGPT, Gemini, Perplexity or Google AI Mode are questions. “How much does it cost?”, “Is it compatible with X?” and “What is the difference between A and B?” are all FAQ-shaped. If your page answers those questions in plain language and labels them as questions, you give retrieval systems a close match for the prompt.

What changed with Google rich results

For years, FAQ markup could earn an expandable rich result in Google Search. In August 2023 Google limited that display: FAQ rich results are now shown only for well-known, authoritative government and health websites. For most other sites, adding FAQPage markup no longer produces the expandable FAQ snippet in search results. Google also announced that it would stop showing HowTo rich results at around the same time.

That change does not make the markup pointless, but it does change the reason to use it. Do not add FAQ schema expecting a visual rich result in Google. Add it because it describes your content accurately, because other consumers of structured data can use it, and because the process of writing it makes the page better.

What the markup does not do

FAQ schema does not make an AI engine cite you, and it does not raise a ranking by itself. No structured data type is a switch that forces visibility. Engines choose sources based on relevance, authority, freshness, how well the content answers the prompt, and whether the page can be fetched and understood. Markup is a clarity signal, not a ranking lever.

How search engines and AI systems read FAQ markup

Google parses JSON-LD from the rendered page and uses it to understand the content and, where eligible, to enable rich results. Because eligibility for FAQ rich results is now narrow, the markup mostly serves understanding. Bing also reads schema.org structured data, and Bing’s index feeds several AI products, so well-formed markup is not wasted there.

Large language model products behave differently depending on how they get your page. Some fetch pages live with their own crawlers and read the HTML, which includes your script tags. Some use a search index and quote passages from it. Others rely on training data collected earlier. In each of these paths, the visible text is the primary signal and the JSON-LD is secondary context. That is one more reason to keep the two identical: if they disagree, you are sending mixed signals.

Crawlers must be able to reach the page

None of this matters if the AI crawler is blocked or if the content only appears after heavy client-side rendering that some bots do not execute. Put the FAQ in the server-rendered HTML where you can, and check your robots rules so that the bots you want are allowed. The free AI crawler robots.txt generator helps with that part.

FAQ schema rules you must follow

Structured data that breaks the rules can be ignored, or in the worst case treated as spam. These are the rules that matter in practice. They come from Google’s structured data guidelines and from schema.org’s definitions.

  • Markup must match visible content. Every question and answer in the JSON-LD must appear on the page, in full, where a visitor can read it. Do not mark up content that is hidden from users or that exists only in the code.
  • The FAQ must be written by you. FAQPage is for questions with a single answer provided by the site. If users can submit competing answers, use QAPage instead.
  • Do not use FAQ markup for advertising. Answers that exist only to promote a product or push a sales message are against the guidelines. Answer the question honestly, and mention your product only where it is the real answer.
  • Do not repeat the same FAQ on many pages. If an identical question appears on several pages of your site, mark it up on only one of them.
  • Each question needs a complete answer. An answer of “See our pricing page” is not an answer. Give the answer in the text, then link for details.
  • Answers may use limited HTML. The text property can include basic tags such as <a>, <p>, <br>, <ul>, <ol>, <li>, <b>, <strong>, <i>, <em> and heading tags. Keep it simple.
  • The page must be indexable. Markup on a page that is blocked by robots rules or marked noindex will not be used.

Best practices

Write questions the way people ask them

Use natural phrasing, not keyword strings. “Do you offer free shipping to Canada?” is better than “Canada free shipping policy.” Real questions come from support tickets, sales calls, live chat logs, search suggestions and the questions people type into AI assistants. Those sources tell you what to include.

Lead each answer with the answer

Put the direct answer in the first sentence, then add detail. “Yes. We ship to Canada, and orders over $75 ship free” is a good start. A retrieval system that quotes only the first sentence still quotes something useful. Aim for answers between roughly 40 and 120 words. Long enough to be complete, short enough to quote.

Keep answers self-contained

An answer should make sense if it is lifted out of the page and shown alone. Avoid “as mentioned above” and “see below.” Repeat the subject of the question in the answer: “Our standard plan includes three seats” rather than “It includes three.”

Choose questions that deserve a place

Five to ten strong questions beat thirty weak ones. Pick questions that real buyers ask: pricing, compatibility, comparisons, setup, limits, cancellation, security. Skip questions nobody asks, such as “Why are we the best?”

Match the markup to the page exactly

Generate the JSON-LD from the final text. If you edit an answer on the page later, edit the markup too. A stale answer in the markup, such as an old price or policy, is worse than no markup, because it can surface incorrect information.

Put the script in the right place

Place the JSON-LD in the <head> or the <body> of the page that contains the FAQ. Either is valid. One FAQPage block per page is the clean approach. If your page also has Article or Organization markup, use separate script tags or combine them in an @graph array.

Validate before and after publishing

Check the code with Google’s Rich Results Test and the Schema Markup Validator at validator.schema.org. The first tells you whether the markup is eligible for Google features. The second checks the syntax against schema.org. Because FAQ rich results are limited, the Rich Results Test may report the page as not eligible for a display even when the code is perfectly valid. That is expected and not an error in your markup.

Keep it fresh

Review your FAQ when prices, policies or product features change. Put a recurring reminder in your content calendar. Answer engines favor current information, and an outdated FAQ erodes trust.

Examples

A minimal FAQPage

This is the smallest valid structure, with two questions. Replace the text with your own.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does shipping take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Standard shipping takes 3 to 5 business days within the United States. Express shipping takes 1 to 2 business days."
      }
    },
    {
      "@type": "Question",
      "name": "Can I return an item?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. You can return unused items within 30 days of delivery for a full refund."
      }
    }
  ]
}
</script>

JSON strings cannot contain raw double quotes or line breaks. Inside the text value, use single quotes for HTML attributes or escape double quotes with a backslash. Here the answer contains a link and a short list. The tool handles this escaping for you.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What payment methods do you accept?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "<p>We accept the following:</p><ul><li>Major credit and debit cards</li><li>Bank transfer for annual plans</li></ul><p>See our <a href=\"https://example.com/billing/\">billing page</a> for details.</p>"
      }
    }
  ]
}
</script>

FAQPage combined with other types using @graph

If a page carries more than one entity, you can place them in one script tag. This keeps the page tidy and lets entities refer to each other by @id.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebPage",
      "@id": "https://example.com/pricing/#webpage",
      "url": "https://example.com/pricing/",
      "name": "Pricing"
    },
    {
      "@type": "FAQPage",
      "@id": "https://example.com/pricing/#faq",
      "isPartOf": { "@id": "https://example.com/pricing/#webpage" },
      "mainEntity": [
        {
          "@type": "Question",
          "name": "Is there a free trial?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Yes. Every plan includes a 2-day free trial."
          }
        }
      ]
    }
  ]
}
</script>

What the visible page should look like

The visible HTML that goes with the first example should show the same text, in a form people can read. A simple heading-and-paragraph pattern is enough.

<h2>Frequently asked questions</h2>

<h3>How long does shipping take?</h3>
<p>Standard shipping takes 3 to 5 business days within the United States.
Express shipping takes 1 to 2 business days.</p>

<h3>Can I return an item?</h3>
<p>Yes. You can return unused items within 30 days of delivery for a full refund.</p>

FAQ schema in common platforms

How you add the code depends on how your site is built. The principle is the same everywhere: the JSON-LD must sit on the page that shows the questions.

WordPress

You can paste the script into a custom HTML block inside the post or page, which keeps the code with the content. Many SEO plugins also include FAQ blocks that output the markup for you. The free aeoora WordPress plugin includes an FAQ block that writes the visible questions and the matching FAQPage markup together, so they cannot drift apart, and it avoids duplicating schema that your SEO plugin already outputs. See the WordPress integration for details.

Static sites and custom builds

Add the script tag to the template for that page, or generate it from the same data file that renders the visible FAQ. Generating both from one source is the most reliable approach, because there is only one place to edit.

Website builders and CMS platforms

Most builders offer a custom code or header injection field at page level. Paste the script there, and make sure it is scoped to the page that shows the FAQ, not sitewide. A sitewide FAQ block that appears on every page, with questions that exist on only one, breaks the visible-content rule.

Common mistakes

  • Marking up content that is not on the page. If a question appears in the JSON-LD but not in the visible text, you are violating the guidelines. Keep both in sync.
  • Hiding the FAQ behind a login or paywall. Crawlers cannot read what they cannot reach, and markup for gated content can cause problems.
  • Using FAQPage for a single question with community answers. That is a QAPage.
  • Writing promotional answers. “Because we are the best” is not an answer. Answer the question, then mention the product only if it fits.
  • Putting the same FAQ block on every page. Mark it up once, on the page that owns it.
  • Broken JSON. Raw double quotes, trailing commas and line breaks inside strings all break parsing. Use the generator or a validator.
  • Expecting a Google rich result. FAQ rich results are limited to well-known government and health sites. Judge the markup by clarity, not by snippet.
  • Letting answers go stale. Old prices and policies in markup can surface wrong information. Review the FAQ whenever the facts change.
  • Answers that are too thin. A two-word answer is not useful to a person or a machine. Give a complete, quotable answer.
  • Duplicating schema from a plugin. If your SEO plugin or theme already outputs FAQPage markup, adding a second copy creates conflicts. Output it once.

Frequently asked questions

Does FAQ schema still work in 2026?

It still works as structured data, but it no longer produces expandable FAQ rich results for most sites. Since August 2023 Google shows those results only for well-known government and health websites. The markup remains valid schema.org, it still describes your content in a machine-readable way, and it is still worth adding when you have a real FAQ section. Just do not expect a visual snippet.

Will FAQ schema make ChatGPT, Perplexity or Google AI Overviews cite my page?

No markup can guarantee that. These engines choose sources based on relevance, authority, freshness and how directly a passage answers the prompt. FAQ schema makes your Q&A pairs easier to interpret, and the exercise of writing direct answers makes the content more quotable, but neither is a guarantee. Treat it as one part of making your pages easy to understand.

Do the questions in the markup have to appear on the page?

Yes. Google requires structured data to reflect content that is visible to users. Every question and answer in your JSON-LD should be readable on the same page, in the same wording. Markup for hidden or absent content can lead to the structured data being ignored.

How many questions should I include?

Include as many as you genuinely answer on the page, but quality matters more than count. Five to ten well-chosen questions is a sensible range for most pages. There is no technical limit in the schema, but a very long FAQ is harder for people to use and tends to include weak entries.

Can I use HTML inside the answer text?

Yes, a limited set of tags is allowed, including links, paragraphs, line breaks, lists, bold and italic. Keep the HTML minimal. Remember that double quotes inside a JSON string must be escaped with a backslash, which the generator does for you.

Should I use JSON-LD, Microdata or RDFa?

Use JSON-LD. Google recommends it, it keeps the markup separate from your HTML, and it is simpler to generate and update. Microdata and RDFa are still valid, but they mix data attributes into your page markup, which makes them harder to maintain.

Can I put FAQPage markup on a product or service page?

Yes, if the page has a visible FAQ section written by you about that product or service. Mark up only the questions that appear on that page. Do not copy the same questions onto every product page. If the same question is on many pages, mark it up on one.

How do I check that my FAQ markup is valid?

Paste the code or the page URL into the Schema Markup Validator at validator.schema.org to check syntax and types. Use Google’s Rich Results Test to see how Google parses the page. Remember that the Rich Results Test may say the page is not eligible for an FAQ display because of the 2023 restriction, even when the markup is correct.

Go further with aeoora

This free tool creates the JSON-LD for one page at a time. If you manage many pages, the work adds up: finding the questions buyers actually ask, writing answers, keeping them current, and checking whether AI engines pick them up. aeoora Cloud handles that loop. It tracks how your brand appears across AI engines, surfaces the questions and query fan-outs where you are missing, and on Signal and above includes an FAQ generator that writes the FAQ section together with the FAQPage markup. The GEO tools documentation explains how it works, and the Site Audit guide shows how schema problems are flagged across your whole site. See plans and pricing, or start a 2-day free trial.

If you run WordPress, the free aeoora plugin gives you FAQ blocks with matching markup, Markdown versions of your pages, llms.txt and AI crawler controls at no cost. Read more on the WordPress integration page. For other generators and checkers, such as the Organization and Article schema tools, browse all of the free tools.