FAQPage vs QAPage vs HowTo: Which Schema to Use in 2026

Short answer: Use FAQPage when you wrote both the questions and the answers, QAPage only when visitors can post answers to a single question, and HowTo for step-by-step instructions. Of the three, only QAPage still has a documented rich result in Google Search: FAQ rich results ended on May 7, 2026, and How-to rich results ended in September 2023. Pick the type that matches the page, not the one with a rich result.

Tested on Nov 3, 2026. What we did: sent six JSON-LD snippets (one of each type, plus three common mix-ups) to the Schema Markup Validator, to Google’s Rich Results Test in code mode, and to our free script, and scanned the markup on 8 pages that rank on Google or Bing for “faqpage vs qapage”. What we did not test: how live pages appear in Google Search, Bing or AI assistants, any effect on rankings, microdata or RDFa, and the Rich Results Test’s URL mode.

What is the difference between FAQPage, QAPage and HowTo?

They describe three different pages. FAQPage is a list of questions the site answered itself. QAPage is one question with answers from users. HowTo is a set of steps. The question to ask is who writes the answers, and how many questions the page is about.

	FAQPage	QAPage	HowTo
Who writes the answers	The site	Users (one can be marked accepted)	No answers, only steps
Questions per page	One or more	Exactly one	None
Google rich result (Nov 2026)	None since May 7, 2026	Documented and still detected	None since Sep 13, 2023
schema.org definition	“presenting one or more Frequently asked questions”	“focussed on a specific Question and its Answer(s)”	“Instructions that explain how to achieve a result by performing a sequence of steps”

One thing trips people up: schema.org’s own QAPage definition mentions FAQs. It reads “e.g. in a question answering site or documenting Frequently Asked Questions (FAQs).” Google’s QAPage guide is narrower and lists “An FAQ page written by the site itself with no way for users to submit alternative answers” as an invalid use. If you care about Google, follow Google’s rule.

Which schema type should I use for my page?

Answer these in order and stop at the first yes. Here is the whole decision as a cheat sheet:

1. Is the page a sequence of steps, with no questions? Use HowTo, or no markup. Google shows no rich result for it.
2. Can visitors post their own answers to one main question? Use QAPage. Google lists “A forum page where users can submit answers to a single question” and “A product support page where users can submit answers to a single question” as valid.
3. Is it a forum thread that is a discussion rather than a question? Google’s discussion forum guide recommends Q&A markup when a forum is “primarily questions with answers”, and says DiscussionForumPosting “would be a better choice” otherwise.
4. Did you write the questions and the answers? Use FAQPage. That covers any FAQ page or FAQ section where the site writes the answers.
5. Is it a homework help page where in-house experts pick the answer? Google has a separate Education Q&A exception for that; read the QAPage guide before marking it up.

A blog post that answers one question is not a QAPage. Google’s QAPage guide names “A blog post that answers a question” and “A how-to guide that answers a question” as invalid uses of QAPage. An FAQPage for a real FAQ section on that post is the honest fit.

Does Google still show rich results for FAQPage, QAPage or HowTo?

Only for QAPage. Google’s structured data gallery, last updated Oct 16, 2026, lists Q&A, Discussion forum and Education Q&A, and has no FAQ or How-to entry. The dates come from Google’s own changelog and blog:

Type	What Google changed	Date
HowTo	Rich results limited to desktop	Aug 8, 2023
FAQPage	Rich results limited to “well-known, authoritative government and health websites”	Aug 8, 2023
HowTo	“Google Search no longer shows How-to rich results on desktop, which means this result type is now deprecated.”	Sep 13, 2023
FAQPage	“This feature will no longer appear in Google Search starting May 7, 2026.”	May 7, 2026
FAQPage	FAQ rich result documentation removed	June 2026
QAPage	“Added more supported properties for Discussion Forum and QA Page markup”	Mar 24, 2026

The old How-to guide URL now opens the changelog note about its removal. So if a page tells you HowTo markup earns a rich result in Google, that page is out of date.

What happened when we tested all three?

The Schema Markup Validator passed all six snippets with 0 errors and 0 warnings. Google’s Rich Results Test detected only the QAPage, and it rejected the two QAPage mistakes that the validator let through:

Snippet	Schema Markup Validator	Rich Results Test	Our script
FAQPage, 2 questions	FAQPage, 0 errors	No items detected	FAQPage: 2 question(s)
QAPage, Google’s required fields	QAPage, 0 errors	1 valid item: Q&A	required properties present
HowTo, 2 steps	HowTo, 0 errors	No items detected	HowTo: 2 steps
FAQPage using suggestedAnswer + answerCount	FAQPage, 0 errors	No items detected	FAQPage: 1 question(s)
QAPage with 2 questions	QAPage, 0 errors	Invalid: Duplicate field “mainEntity”	mainEntity holds 2 Question items
QAPage without answerCount	QAPage, 0 errors	Invalid: Missing field “answerCount”	no integer answerCount

Two lessons. First, in our test the Schema Markup Validator caught neither of the two QAPage rules we broke; the Rich Results Test and our script caught both. Second, “No items detected” for FAQPage and HowTo is expected now. It does not mean your markup is broken, only that Google has no rich result left to test it against.

Can I use QAPage on my FAQ section to get a rich result?

No. Google’s QAPage guide says “Users must be able to submit answers to the question” and “Don’t use QAPage markup for FAQ pages or pages where there are multiple questions per page.” It also expects exactly one Question per page. A multi-question FAQ section you wrote fails both rules.

Our test shows what happens if you try anyway. A QAPage with two questions came back invalid in the Rich Results Test, with the critical issue Duplicate field “mainEntity”. Splitting the FAQ into one page per question does not fix the first rule either: the answers still come from you, not from users. Google’s general guidelines also say “Don’t mark up content that is not visible to readers of the page,” so the markup has to match a real Q&A thread on the page.

Can FAQPage use suggestedAnswer or answerCount?

Yes, as far as schema.org is concerned. Both are properties of Question, not of QAPage, so any Question can carry them, including one inside an FAQPage. The validator gave our FAQPage built with suggestedAnswer and answerCount 0 errors.

For an FAQ you wrote yourself, acceptedAnswer is the plainer fit: schema.org describes it as the answer “accepted as best”. And the Rich Results Test said nothing about it. It reported “No items detected” for that snippet, not an error about a missing acceptedAnswer.

What does a valid QAPage look like?

Here is the QAPage snippet that the Rich Results Test accepted as “1 valid item detected”. It is one question, two answers, and an answerCount that matches the answers on the page. Swap in your own thread’s data:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "QAPage",
  "mainEntity": {
    "@type": "Question",
    "name": "Why does my WordPress llms.txt return a 404?",
    "text": "I turned on llms.txt in my plugin, but example.com/llms.txt shows a 404 page. What should I check?",
    "answerCount": 2,
    "datePublished": "2026-10-30T09:15:00-04:00",
    "author": { "@type": "Person", "name": "Sam", "url": "https://example.com/users/sam" },
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Go to Settings, then Permalinks, and click Save Changes. That refreshes the rewrite rules.",
      "upvoteCount": 4,
      "url": "https://example.com/questions/llms-txt-404#answer-1",
      "datePublished": "2026-10-30T10:02:00-04:00",
      "author": { "@type": "Person", "name": "Lee", "url": "https://example.com/users/lee" }
    },
    "suggestedAnswer": [
      {
        "@type": "Answer",
        "text": "Check that no static llms.txt file is sitting in your web root.",
        "upvoteCount": 1,
        "url": "https://example.com/questions/llms-txt-404#answer-2",
        "datePublished": "2026-10-30T11:40:00-04:00",
        "author": { "@type": "Person", "name": "Kim", "url": "https://example.com/users/kim" }
      }
    ]
  }
}
</script>

Google’s guide adds three rules worth repeating:

• answerCount is required, and “may also be 0 for questions with no answers.” Questions without answers are not eligible for the rich result.
• acceptedAnswer must be accepted “by question asker, a moderator, or a voting system.” Sorting by newest does not count.
• Only one QAPage and only one Question per page.

How can I check which type a page uses?

Run our free script. It reads the JSON-LD on a URL or a saved HTML file, finds every FAQPage, QAPage and HowTo (also inside an @graph), and checks each QAPage against Google’s required properties. Save it as schema-type-check.py and run python3 schema-type-check.py https://your-site.com/page/. It needs Python 3 and nothing else; it uses certifi’s CA list when certifi is installed.

#!/usr/bin/env python3
"""schema-type-check.py - find FAQPage, QAPage and HowTo in a page's JSON-LD.

Usage:  python3 schema-type-check.py https://example.com/page/
        python3 schema-type-check.py saved-page.html

Reads JSON-LD only (not microdata or RDFa). QAPage nodes are checked against
the required properties in Google's QAPage documentation (as of Nov 3, 2026).
"""
import json, re, ssl, sys, urllib.request

def load(src):
    if not src.startswith(("http://", "https://")):
        return open(src, encoding="utf-8").read()
    try:  # use certifi's CA list when it is installed
        import certifi
        ctx = ssl.create_default_context(cafile=certifi.where())
    except ImportError:
        ctx = ssl.create_default_context()
    req = urllib.request.Request(src, headers={"User-Agent": "Mozilla/5.0 schema-type-check"})
    return urllib.request.urlopen(req, context=ctx, timeout=30).read().decode("utf-8", "replace")

def nodes(x):
    """Yield every dict in a JSON-LD tree (top level, @graph, nested values)."""
    if isinstance(x, list):
        for i in x: yield from nodes(i)
    elif isinstance(x, dict):
        yield x
        for v in x.values(): yield from nodes(v)

def types(n):
    t = n.get("@type", [])
    return {str(i).rsplit("/", 1)[-1] for i in (t if isinstance(t, list) else [t])}

def as_list(v):
    return v if isinstance(v, list) else ([] if v is None else [v])

def check_qapage(qa):
    probs = []
    qs = [q for q in as_list(qa.get("mainEntity")) if isinstance(q, dict) and "Question" in types(q)]
    if len(qs) != 1:
        return [f"mainEntity holds {len(qs)} Question items; Google expects exactly one"]
    q = qs[0]
    if not q.get("name"): probs.append("Question has no name")
    if not isinstance(q.get("answerCount"), int): probs.append("Question has no integer answerCount")
    answers = as_list(q.get("acceptedAnswer")) + as_list(q.get("suggestedAnswer"))
    if not answers: probs.append("Question has no acceptedAnswer or suggestedAnswer")
    for a in answers:
        if not (isinstance(a, dict) and a.get("text")): probs.append("an Answer has no text")
    return probs

def main(src):
    try:
        page = load(src)
    except Exception as e:  # e.g. HTTP 403: save the page in a browser and pass the file
        print(f"{src}\n  could not fetch: {e}")
        return
    blocks = re.findall(r'<script[^>]+application/ld\+json[^>]*>(.*?)</script>', page, re.S | re.I)
    print(f"{src}\n  JSON-LD blocks: {len(blocks)}")
    found = {"FAQPage": [], "QAPage": [], "HowTo": []}
    for i, b in enumerate(blocks, 1):
        try:
            data = json.loads(b)
        except json.JSONDecodeError as e:
            print(f"  block {i}: NOT VALID JSON - {e}")
            continue
        for n in nodes(data):
            for t in types(n) & found.keys():
                found[t].append(n)
    for n in found["FAQPage"]:
        qs = [q for q in as_list(n.get("mainEntity")) if isinstance(q, dict)]
        print(f"  FAQPage: {len(qs)} question(s). Google stopped showing FAQ rich results on May 7, 2026.")
    if len(found["QAPage"]) > 1:
        print(f"  QAPage: {len(found['QAPage'])} found; Google allows one per page")
    for n in found["QAPage"]:
        probs = check_qapage(n)
        print("  QAPage: " + ("required properties present" if not probs else "; ".join(probs)))
    for n in found["HowTo"]:
        print(f"  HowTo: {len(as_list(n.get('step')))} steps. Google stopped showing How-to rich results in September 2023.")
    if not any(found.values()):
        print("  none of FAQPage, QAPage, HowTo found")

if __name__ == "__main__":
    for arg in sys.argv[1:] or ["-h"]:
        if arg in ("-h", "--help"):
            print(__doc__); break
        main(arg)

Here is its output on two live pages. Some sites block scripts, as the second one did; save that page from your browser and pass the file instead:

$ python3 schema-type-check.py https://answerschema.com/does-faq-schema-still-work/
Does FAQ Schema Still Work in 2026? We Tested It on a Live Site

  JSON-LD blocks: 2
  FAQPage: 5 question(s). Google stopped showing FAQ rich results on May 7, 2026.

$ python3 schema-type-check.py https://wordpress.stackexchange.com/questions/108293/
https://wordpress.stackexchange.com/questions/108293/
  could not fetch: HTTP Error 403: Forbidden

What do the top “FAQPage vs QAPage” pages get wrong?

Mostly the dates. We read 4 of the Google results and 4 of the Bing top-10 results for “faqpage vs qapage” and scanned their own markup:

• Five describe only Google’s 2023 cutback and never mention the May 2026 end. One, dated Aug 11, 2026, says Google “restricted FAQ rich results in 2023 to a small set of authoritative government and health sites”; another says they are “now almost exclusively shown for government and health websites.” Two others, SearchScore and AI Schema Gen, give the May 2026 date.
• One says Google “scaled back” HowTo display. Google deprecated How-to rich results in September 2023.
• Two say answerCount or suggestedAnswer belong only to QAPage. On schema.org they are Question properties.
• Two say the Rich Results Test flags an FAQ built with suggestedAnswer; one names the error “Missing field acceptedAnswer”. In our test the tool reported no items for it.
• None of the 8 pages carries QAPage in its JSON-LD. Five carry FAQPage, and one of those also carries HowTo.

Should I remove FAQPage or HowTo markup now?

You don’t have to remove FAQPage. When Google cut back FAQ results in 2023, it wrote: “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.” Keep FAQPage if it describes a real FAQ on the page, and drop HowTo if you only added it for the old How-to rich result.

Don’t add either one expecting AI answers to pick you. Google’s AI features guide says “Structured data isn’t required for generative AI search, and there’s no special schema.org markup you need to add.” For our own live test of FAQ markup, see Does FAQ Schema Still Work in 2026?, and for four validated FAQPage snippets, see our FAQ schema example post.

Where does our free plugin fit?

FAQ Schema & AI FAQ Generator is our free WordPress plugin, and it writes FAQPage markup only. Its FAQ block shows your questions on the page and adds the FAQPage JSON-LD from the same content. It does not write QAPage or HowTo, so it fits the FAQ sections you write yourself, not forum threads. Not on WordPress? Our free FAQ schema generator builds the same FAQPage code in your browser.