HowTo Schema Markup in 2026: Why It Still Belongs on AI Tutorials Even Though Google Retired the Rich Snippet

HowTo structured data still works exactly as schema.org defines it, but Google stopped turning it into a visual rich result on September 13, 2023 — first on mobile that August, then everywhere a month later. The vocabulary itself was never deprecated; only Google’s search-results treatment of it was. That distinction matters because most “add HowTo schema” guides online were written, or last updated, while the rich snippet still existed, and several still show screenshots of a result Google no longer renders.

What actually happened, in order

1. August 8, 2023 — Google announced HowTo rich results would stop showing on mobile search and appear only on desktop.
2. September 13, 2023 — Google removed HowTo rich results from desktop too, ending the feature on every surface.
3. September 14, 2023 — Google deleted its own HowTo structured data documentation page and its case study. The URL that used to host that guide now redirects to Search Central’s general changelog, where the removal is logged as two separate entries: the documentation and the case study.

That third point is easy to miss because it isn’t something Google announced loudly — it only shows up if you follow the old documentation link and notice where it lands now. A related, later change makes the same point from a different schema type: Google’s changelog records a May 8, 2026 deprecation notice and a June 15, 2026 removal of the FAQ rich result’s documentation, which we cover in detail in our look at the FAQPage schema removal. Google treats “stop showing the rich result” and “stop documenting the markup” as two distinct steps, months or years apart, and most advice online only tracks the first one.

Should you still mark up HowTo content? A checklist

• Don’t add it expecting a Google rich snippet. That outcome was removed in 2023 and isn’t coming back for a general-purpose site; the June 2026 FAQ precedent shows Google trending toward fewer of these features, not more.
• Do add it if an AI assistant reading your page benefits from seeing discrete, numbered steps. HowTo’s step array is a clean, machine-readable way to say “these five actions are the procedure,” which is exactly the kind of structure a model answering “how do I do X” can quote back accurately.
• Don’t use HowTo for content that isn’t actually a sequence. A listicle of five unrelated tips is not a HowTo, and marking it up as one misrepresents the content to anything parsing the schema — the same abuse pattern covered in our audit checklist for Google’s scaled content abuse policy.
• Do keep the markup if removing it is the only reason you’d touch the page. Google’s own guidance on this kind of change is that unused structured data causes no problems; there’s no indexing penalty for HowTo markup that no longer triggers a rich result.
• Don’t let a schema plugin add HowTo automatically to every post with a numbered list. Check what’s actually being generated, the same way you’d check what Rank Math fills in automatically for Article schema versus what Google’s guidelines still expect you to supply by hand.

A minimal HowTo block, with each field explained

This is the smallest version that stays valid against the current schema.org definition, written for a tutorial post rather than a recipe or a physical task:

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to rotate a Claude API key without downtime",
  "description": "Issue a second key, cut traffic over to it, then revoke the old one.",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Issue a second key",
      "text": "Create a new API key in the console without deleting the old one."
    },
    {
      "@type": "HowToStep",
      "name": "Cut traffic over",
      "text": "Deploy the new key to your application and confirm requests succeed."
    },
    {
      "@type": "HowToStep",
      "name": "Revoke the old key",
      "text": "Once traffic is confirmed on the new key, revoke the old one."
    }
  ]
}

• name and description exist because a HowTo with no title or summary gives a parser nothing to label the procedure with — this is the field Google’s own removed documentation used to call required, and schema.org still lists it as expected.
• step is the only part that actually matters for an AI answer engine. Each HowToStep needs its own name (a short label) and text (the instruction itself), because a model quoting one step back to a user needs that step to stand alone, without the surrounding ones for context.
• Fields left out here on purpose: totalTime, estimatedCost, and tool/supply are valid HowTo properties, but adding them to a procedure that has no duration, cost, or physical tools just because the schema allows it is the same over-marking problem as a fake FAQ block.

Mistakes that show up even in technically valid markup

• Steps out of execution order. The step array’s order is the only signal a parser has for sequence — there’s no explicit position requirement the way some list schemas have, so a step pasted in the wrong place silently reverses part of the procedure for anything reading the markup instead of the visible page.
• One step doing two things. “Install the package and configure your API key” packed into a single HowToStep hides a step boundary a user, or a model, would reasonably expect to see split out.
• Marking up a comparison as a procedure. “How to choose between Claude and GPT” is a decision framework, not a sequence — it has no “step 1, step 2, step 3” a reader actually performs in order, and schema.org’s own structure assumes that it does.
• Forgetting the markup still has to match the visible page. Google’s general structured data guidelines haven’t changed on this point even where the rich result has: content in the schema must reflect what a visitor actually sees, whether or not that markup currently produces a search feature.

None of this changes if Google reintroduces a HowTo rich result later — the FAQ timeline above shows Google revisiting these decisions years apart, in both directions. What doesn’t depend on Google’s rich-result roadmap is whether an AI engine summarizing your tutorial can tell, from the markup alone, which numbered item is step two. That’s the bar worth writing to.

Why Google pulled it in the first place

Google’s own announcement framed the September 2023 change as “providing a cleaner and more consistent search experience,” without pointing to abuse or overuse as the cause. Google’s John Mueller was asked directly whether the removal was a response to sites gaming the feature and said it wasn’t — in his words, “it’s important to clean up from time to time.” On the related FAQ change rolled into the same announcement, Google’s Ryan Levering offered a sharper reason: FAQ markup “was making structured data look like a spam vector,” because so many pages were wrapping unrelated content in fake question-and-answer pairs just to claim the extra search-results real estate. HowTo didn’t get a reason that specific, but the pattern — a rich result becoming a target for markup that technically validates but misrepresents the page — is the same one Article schema runs into when it passes the Rich Results Test but still loses the snippet: passing validation and deserving the result turned out to be two different things, for HowTo and FAQ alike.

That history is also why “will Google bring HowTo back” is the wrong question to plan around. The FAQ timeline shows the opposite trend just as clearly: a feature that survived in a reduced form for government and health sites since 2023 still lost its documentation entirely in 2026. Google has shown it will narrow or remove a rich result years after the first cut, not only widen it back out, so writing HowTo markup on the bet that the snippet returns is planning for the less likely outcome.

What this is actually for now

With the search-results payoff gone, the only remaining reason to write correct HowTo markup is making a procedure easier for software to parse accurately — and that software is increasingly an AI assistant summarizing or quoting your page rather than a search engine deciding whether to show a snippet. A step array with one clear instruction per item removes the ambiguity a model would otherwise have to resolve from prose alone: where does step two actually end and step three begin, and did the page mean for you to do two things in one step or one thing twice. That’s a narrower, humbler use case than “get a rich result,” and it doesn’t require a plugin, a position in a changelog, or Google’s cooperation at all — it just requires the markup to be true to the page, which is the same baseline covered in our breakdown of what llms.txt actually requires for signaling structure to AI crawlers more broadly. Treat HowTo the way you’d treat any other piece of semantic markup with no visible reward attached: write it because it’s accurate, not because something used to light up for it.

Featured image: woodworking hand tools laid out on timber planks, by A S M Jobaer, licensed CC BY-SA 4.0, via Wikimedia Commons.

Sources: Google Search Central — How-to structured data (now redirecting to the documentation changelog, which records the September 14, 2023 removal), schema.org — HowTo, and Search Engine Land’s report on the September 13, 2023 removal.