FAQ Schema vs HowTo Schema vs Article Schema Compared

FAQ schema vs HowTo schema vs Article schema is the wrong fight — they are three answers to three different machine questions, and most content pages should carry more than one. But choosing wrongly is easy: the three types get lumped together as "content schema," and generic advice rarely says which one describes what, or what happens when the markup and the visible page disagree. This comparison walks each type with a short JSON-LD example, puts them side by side in one table, shows how they legally coexist on a single page, and covers the mistakes that get markup ignored by every system that reads it. By the end, "which schema should this page have" should feel like a mechanical question rather than a guess.

What does FAQ schema actually describe?

Direct answer: FAQPage schema describes a page, or page section, made of question-and-answer pairs. Each pair is a Question entity with an acceptedAnswer. It tells machines "these are discrete, standalone answers," which maps directly onto how AI engines lift passages. Use it wherever you genuinely answer recurring user questions.

The structure is the simplest of the three. A FAQPage carries a mainEntity array; each entry is a Question with a name (the question text) and an acceptedAnswer containing the answer text:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "Does blocking GPTBot affect ChatGPT search citations?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "No. GPTBot governs training data. Search-mode citations rely on OAI-SearchBot, a separate crawler."
    }
  }]
}

Why it matters for AI search specifically: retrieval systems select passages, and an FAQ pair is a pre-cut passage — a question in the exact phrasing users ask, welded to a self-contained answer. FAQPage markup hands that pairing to machines as typed data instead of making them infer it from your HTML.

One expectation to set honestly: Google restricted FAQ rich results in 2023 to a narrow set of authoritative sites, so most businesses should not expect expandable FAQ snippets in Google anymore. That changed the decorative payoff, not the structural one — the markup still describes your Q&A content to anything parsing structured data. Write each answer as a standalone 40-to-60-word block; the writing rules are in how to add FAQ schema AI engines can actually use.

What does HowTo schema actually describe?

Direct answer: HowTo schema describes a task with ordered steps: each HowToStep has a name and text, and the whole thing can carry tools, supplies, and time estimates. Google retired HowTo rich results in 2023, but the markup still tells any AI system reading structured data exactly what sequence your page teaches.

HowTo is the most content-demanding of the three types, because it asserts something specific: this page teaches a procedure with a defined outcome, achieved through ordered steps. The markup mirrors that claim:

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to create an llms.txt file",
  "totalTime": "PT30M",
  "step": [{
    "@type": "HowToStep",
    "name": "Inventory your key pages",
    "text": "List the pages that best explain your business and answer buyer questions."
  }, {
    "@type": "HowToStep",
    "name": "Write and upload the file",
    "text": "Draft the markdown summary and place llms.txt at your site root."
  }]
}

The honest status report: Google removed HowTo rich results from its search pages in 2023, so, as with FAQ markup, nobody should implement this expecting visual treatment in Google. The reason to still use it is the machine-comprehension case. A how-to page's value is its sequence — what order, what prerequisites, what result — and HowTo markup is the only one of the three types that encodes sequence at all.

The discipline it imposes is a quiet benefit. You cannot mark up a meandering essay as HowTo without lying, because the schema demands discrete named steps. If your page cannot fill the step array truthfully, that is a signal the content is not actually a how-to yet — fix the page, and the markup follows. Reserve the type for genuine procedures, not for anything with "how" in the title.

What does Article schema actually describe?

Direct answer: Article schema describes the page itself: headline, author, publisher, datePublished, and dateModified. It does not structure the content the way FAQPage or HowTo do. Its job is provenance, saying who wrote this, for which organization, and when, which is the machine-readable backbone of authorship and trust signals.

Where FAQPage and HowTo describe what is on the page, Article describes the page as a published thing in the world:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "FAQ Schema vs HowTo Schema vs Article Schema Compared",
  "datePublished": "2026-05-29",
  "dateModified": "2026-05-29",
  "author": {
    "@type": "Person",
    "name": "Joe Della Mora",
    "jobTitle": "Founder"
  },
  "publisher": {
    "@type": "Organization",
    "name": "GroundScore"
  }
}

This is the type that carries your credibility signals. When an engine weighs whether a passage is safe to cite, attribution is part of the calculation: a claim from a named author at an identifiable organization, with honest dates, is easier to trust than the same words floating anonymously. Article markup is how a page states that provenance in a form machines do not have to guess at — especially when author and publisher reference the same Person and Organization entities you define elsewhere on the site.

It is also the least optional of the three. FAQ and HowTo apply only when the content has their shape; Article (or its subtype BlogPosting) applies to essentially every editorial page you publish. If you adopt exactly one schema type from this comparison, adopt this one, wire it to a real Organization definition, and keep dateModified truthful — a date that moves without content changing reads as manipulation to anything comparing versions.

How do the three schema types compare?

Direct answer: FAQPage structures answers, HowTo structures steps, and Article establishes provenance. They answer different machine questions: "what discrete answers live here," "what sequence does this teach," and "who published this, when." They are complements, not competitors, and the right page often carries Article plus one of the other two.

The side-by-side:

	FAQPage	HowTo	Article
Describes	Question-answer pairs	An ordered procedure	The page's provenance
Core properties	mainEntity, acceptedAnswer	step, name, text, totalTime	headline, author, datePublished
Content it requires	Real Q&A visible on page	Discrete, ordered steps	Any editorial page
Google rich results	Restricted since 2023	Retired in 2023	Still supported
AI-search value	Pre-cut citable passages	Machine-readable sequence	Trust and attribution
Classic mistake	Markup without visible FAQs	Forcing non-tasks into steps	Fake or missing dates

Three readings of that table. First, the decision rule falls out of the "describes" row: match the type to the shape of the content, not to the keyword in the title. A page of questions gets FAQPage; a procedure gets HowTo; everything editorial gets Article underneath.

Second, the rich-results row explains why so much schema advice online feels stale. Both FAQ and HowTo lost their Google decoration in 2023, and advice written for that payoff never updated. The remaining case — machine comprehension for systems that read structured data — is less visible but is precisely the one that matters for AI search.

Third, the mistake row shares a root cause: markup drifting from visible content. Every classic failure here is a version of saying something in JSON-LD that the rendered page does not back up. That is also the fix — one rule, applied three ways.

If you want the decision as a quick mapping for common page types: a service page usually wants Article plus FAQPage, since buyers bring recurring questions to it. A tutorial or setup guide wants Article plus HowTo, assuming the steps are real and ordered. A blog post like this one wants Article at minimum, with FAQPage covering its question section. A pricing page wants FAQPage almost by definition. Nothing on that list requires choosing one type at the expense of another — the choice is only ever about which shapes are truthfully present on the page. Schema types beyond these three, like Organization and LocalBusiness, solve a different problem — identity rather than content — and we covered those in the schema types that matter most for AI search.

Can all three coexist on one page?

Direct answer: Yes. A page can carry Article, FAQPage, and HowTo markup simultaneously, either as separate JSON-LD blocks or one @graph array. The rule is that every marked-up element must exist visibly on the page. Mark up the how-to steps you show and the FAQs you display, nothing more.

Coexistence is normal, not a trick. A well-built tutorial page is often all three things at once: an editorial page (Article), teaching a procedure (HowTo), with a question section at the end (FAQPage). The cleanest implementation is a single script block using @graph:

{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Article", "headline": "How to create an llms.txt file" },
    { "@type": "HowTo", "name": "Create llms.txt", "step": [] },
    { "@type": "FAQPage", "mainEntity": [] }
  ]
}

Each node still has to be complete and truthful on its own; @graph just packages them. Separate script tags work identically — parsers do not care, so pick whichever your CMS makes easier to maintain.

Building GroundScore, the most common schema mistake I see when we scan sites is not a missing type — it is mismatch: FAQPage markup left behind after the visible FAQ section was redesigned away, or steps in HowTo markup that no longer match the steps on the page. Markup that contradicts the rendered page is worse than no markup, because it flags the site as unreliable to exactly the systems it was meant to persuade.

So validate on the way out, and re-validate when the page changes. The schema.org validator checks that your JSON-LD is structurally sound, and Google's rich results test shows how its parser reads the page. Neither checks truthfulness against your visible content — that part stays your job.

Frequently asked questions

Which schema type should I add first?

Article, wired to a real Organization. It applies to every editorial page, carries the authorship and date signals that make everything else attributable, and takes minutes per template rather than per page. Add FAQPage where you genuinely answer questions, and HowTo only on true procedural content.

Is FAQ schema still worth adding after Google restricted rich results?

Yes, with adjusted expectations. The 2023 restriction removed the expandable snippets most sites once chased, but the markup's structural job is intact: it hands machines your question-and-answer pairs as typed data. For AI search, where passages get lifted into answers, pre-structured Q&A remains among the most useful markup you can ship.

Does HowTo schema do anything since Google retired its rich results?

Its decorative payoff in Google is gone, but the markup still encodes something no other common type does: sequence. Any system reading structured data learns exactly what procedure your page teaches, in what order, with what time commitment. Treat it as cheap machine-comprehension insurance on genuine tutorial content, not a rankings lever.

Can conflicting schema types hurt my site?

Multiple types on one page are fine; contradictions are the hazard. Markup describing FAQs that are not visible, steps that do not match the page, or dates that move without edits reads as unreliable to parsers comparing markup against content. Keep every marked-up element visible and current, and coexistence is safe.

Do AI engines actually read schema markup?

Structured data is machine-readable by design, and engines that crawl pages can consume it alongside HTML — that is the practical bet behind marking up. It is not a magic switch: schema clarifies content for machines, it does not compensate for content that answers nothing. Clear pages plus honest markup is the working combination.

How do I check my schema is implemented correctly?

Validate twice. The schema.org validator confirms your JSON-LD parses and the types are well-formed; Google's rich results test shows how a real parser interprets the live page. Then do the check tools cannot: read the page and confirm every marked-up question, step, and date actually appears in the visible content.

The bottom line

FAQPage structures your answers, HowTo structures your steps, and Article signs the whole page — three types, three jobs, no rivalry. Match each to content that genuinely has its shape, let Article underpin everything editorial, and hold one line above all: the markup never says anything the visible page does not.

Schema is one of the easiest AI-visibility signals to get right, and one of the most common to find broken. Run a free AI visibility check to see how your site's structure reads to the engines — it takes about a minute, no account needed.