Is HowTo Schema Still Worth Using in 2026?

HowTo rich results have been gone from Google for nearly three years, and a surprising number of people still don't know. Unlike the FAQ deprecation in May 2026, which generated weeks of discussion, this one happened quietly and most of the internet simply never updated.

So if you're maintaining HowTo markup, or wondering whether to add it, here's the current picture, including one detail about HowTo that almost nobody gets right.

What happened, and when

Google removed HowTo rich results from mobile search results in August 2023, and from desktop the following month. By September 2023 the feature was gone from every surface and the supporting documentation was cleared out.

It hasn't come back. HowTo does not appear in Google's structured data gallery today, which lists the 25 features Google currently supports.

The reasoning was never elaborated in detail, but the pattern is consistent with what Google has said about later retirements: features that were underused, or that no longer added enough value to the search experience, get removed to simplify results.

The markup is not deprecated

This is the distinction that matters, and it's the same one that trips people up with FAQPage.

Google retired a search feature. schema.org did not retire the type. HowTo, HowToStep, HowToSection, HowToSupply, and HowToTool all remain valid schema.org types. Your markup will validate. It will not throw errors, will not trigger a manual action, and will not damage your rankings.

Google has consistently stated that these presentation changes don't affect rankings, and that its systems ignore unsupported structured data without penalty. There is no version of this where leaving valid HowTo markup on your site hurts you.

What you don't get is the visual step-by-step display that used to appear beneath your listing. That's the whole consequence.

What valid HowTo markup looks like

Since the documentation was removed, it's become genuinely hard to find a correct, complete example. Here's what the markup looks like in full: a hardware repair guide with supplies, tools, and sequential steps:

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Replace a Laptop Battery",
  "description": "Step-by-step instructions for safely replacing an internal laptop battery.",
  "image": "https://example.com/images/battery-replacement.jpg",
  "totalTime": "PT25M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": "45"
  },
  "supply": [
    { "@type": "HowToSupply", "name": "Replacement battery" },
    { "@type": "HowToSupply", "name": "Thermal-safe adhesive strips" }
  ],
  "tool": [
    { "@type": "HowToTool", "name": "Phillips #00 screwdriver" },
    { "@type": "HowToTool", "name": "Plastic spudger" }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "Power down and discharge",
      "text": "Shut down the laptop fully and hold the power button for 15 seconds to discharge residual current.",
      "url": "https://example.com/battery-guide#step1",
      "image": "https://example.com/images/step1.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Remove the base panel",
      "text": "Unscrew the ten Phillips screws around the base and lift the panel with a spudger.",
      "url": "https://example.com/battery-guide#step2"
    },
    {
      "@type": "HowToStep",
      "name": "Disconnect and swap the battery",
      "text": "Unclip the battery connector, lift the old cell out, and seat the replacement.",
      "url": "https://example.com/battery-guide#step3"
    }
  ]
}

A few things worth noting about this structure, because they carry over to other types:

step takes an array of HowToStep objects, not a text blob. Each step is a discrete object with its own name and text. This is the single most important structural decision in the whole type, and it's the one people most often get wrong.

Each step can carry its own url anchor. Pointing at a fragment on your own page (#step2) lets a machine associate the structured step with the exact place it appears in the visible content. This is good practice regardless of rich result eligibility.

supply and tool are distinct. Supplies are consumed by the process; tools are reused. Conflating them is common and inaccurate.

totalTime uses ISO 8601 duration format. PT25M is 25 minutes. Plain-English times won't validate: the same requirement that catches people out with Recipe.

HowToSection exists for longer processes that group into phases. If your guide has "Preparation," "Installation," and "Testing" stages, wrap the relevant steps in sections rather than presenting twenty flat steps.

The part almost nobody knows: HowToStep is still supported

Here's the wrinkle.

HowTo as a standalone rich result is gone. But HowToStep (the type describing an individual step) is still actively used inside Recipe schema, and Recipe is very much supported by Google today.

When you mark up a recipe's method, the correct pattern is recipeInstructions containing an array of HowToStep objects rather than one block of text. That's not a workaround or a legacy quirk; it's the current recommended structure, and it's part of what enables step-by-step recipe displays in Google.

Here's the difference in practice. This is the pattern that forfeits the rich result:

{
  "@type": "Recipe",
  "name": "Weeknight Lemon Garlic Pasta",
  "recipeInstructions": "Cook the spaghetti until al dente. Saute the garlic in olive oil, then add the lemon. Toss the pasta with the sauce and parmesan."
}

And this is the pattern Google can actually parse into steps:

{
  "@type": "Recipe",
  "name": "Weeknight Lemon Garlic Pasta",
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "text": "Cook the spaghetti until al dente."
    },
    {
      "@type": "HowToStep",
      "text": "Saute the garlic in olive oil, then add the lemon."
    },
    {
      "@type": "HowToStep",
      "text": "Toss the pasta with the sauce and parmesan."
    }
  ]
}

Same content, same recipe, completely different machine-readability. The first tells a crawler "here is some text." The second tells it "here are three sequential steps, and this is where each begins and ends."

So the HowTo vocabulary didn't die. It got absorbed. Its most useful component now does its best work inside a schema type that still earns a prominent rich result. If you publish recipes, you're almost certainly using HowToStep whether you realised it or not, and if your recipeInstructions is currently a paragraph of text, you're leaving a supported rich result on the table. We cover the full pattern in the recipe schema guide.

Which type should procedural content use?

If your page explains how to do something, you have several options and they aren't interchangeable. This is how they compare:

The practical takeaway for most instructional publishers: mark the page up as Article or BlogPosting (supported, and you should be doing it anyway), add VideoObject if you have a video (supported, and video suits procedural content particularly well), and layer HowTo on top if you want the structural description for non-Google systems. That combination gets you every rich result currently available for this kind of content.

Should you keep existing HowTo markup?

Yes, with the same reasoning that applies to FAQPage.

Removing it gains you nothing. There's no penalty to escape and no cleanup benefit. You'd be spending hours to achieve a neutral outcome.

Other systems still parse it. Bing processes structured data on its own terms, and AI crawlers read markup when assembling answers. Google's decision about its own SERP doesn't govern what anyone else does with your data.

It still labels your content for machines. HowTo markup explicitly states that this page describes a process, that these are the sequential steps, that these are the required supplies and tools. A crawler reading unstructured HTML has to infer all of that from headings and formatting. The markup removes the guesswork, which was always the actual function of structured data, independent of whether Google drew a box around it.

Do audit it for accuracy. The one genuine risk is unchanged and predates the deprecation: markup describing content that isn't visible on the page. Orphaned HowTo blocks left behind on pages whose step-by-step sections were rewritten are worth finding and removing.

A practical audit looks like this:

1. Find every page carrying HowTo markup. A site-wide structured data crawl is the fastest route; a site: search combined with source inspection works for smaller sites.
2. Check each marked-up step against the rendered page. Every HowToStep in your JSON-LD should correspond to a step a visitor can actually see. Steps that were edited out of the copy but left in the markup are the exact pattern that constitutes a policy violation.
3. Check supply and tool lists. These drift particularly badly, because writers update the visible list without touching the markup.
4. Check for duplicate or conflicting blocks. Sites that have been through two or three plugins often carry more than one HowTo block per page, sometimes contradicting each other.
5. Validate the syntax. The Rich Results Test no longer reports on HowTo since the feature is gone, so use the Schema Markup Validator for generic syntax checking instead.

Point 5 is worth dwelling on, because it changes your QA process. The Rich Results Test was never a general validator: it checked eligibility for specific Google features. For deprecated types it now returns nothing useful, which people misread as "my markup is broken." It isn't; the tool simply has nothing to report. Generic schema.org validation is the right check now.

Should you add it to new content?

Here I'd be honest rather than promotional: it depends on what you're optimizing for, and the answer is less clear-cut than for Recipe or Product.

If you want a visible Google feature, no, there isn't one, and no amount of markup creates one. Put that effort into types that still produce rich results. Our complete list of what Google supports in 2026 covers where the return actually is.

If you're publishing genuine procedural content (repair guides, software walkthroughs, craft tutorials), the markup is cheap to generate, harmless, and gives non-Google systems a clean structural description of your process. That's a reasonable bet, not a guaranteed return.

If your how-to content is a recipe, use Recipe schema with HowToStep instructions. That's not a consolation prize; it's a supported rich result.

We make a schema generation plugin, so treat our enthusiasm accordingly. The honest position is that HowTo markup is now a low-cost, low-certainty investment rather than a clear win, and anyone telling you it's essential is overselling. If you do add it, see the setup documentation for how AI Schema Gen handles HowTo generation and validation.

The bigger issue for how-to publishers

If you write instructional content, the loss of the rich result is not your main problem.

How-to queries are among the most heavily absorbed by AI Overviews. "How do I reset my router," "how to remove a wine stain," "how to install a ceiling fan": these are exactly the questions AI-generated answers handle well, because they have a clear procedural structure and a definite answer. The SERP real estate that used to hold your step-by-step preview is increasingly occupied by a synthesized response.

That's a content strategy question, not a markup question, and no schema type solves it. What tends to survive is instructional content offering something a synthesized summary can't: original photography of the actual process, hard-won troubleshooting for the ways it goes wrong, specific product or model coverage, demonstrated first-hand experience.

Structured data supports that by making authorship, publication dates, and page structure legible to machines. It doesn't substitute for it. Be sceptical of anyone selling markup as the answer to AI Overview displacement, including us, if we ever phrase it that way.

What other engines and AI systems do with it

Google's SERP is one consumer of structured data. It isn't the only one, and this is where the remaining value of HowTo markup sits.

Bing processes structured data independently. Bing's own webmaster guidance covers structured data support, and its handling of markup is not governed by Google's product decisions. DuckDuckGo, which runs on Bing's index, and Brave Search process markup on the same basis. Google removing a feature from its own results changed nothing about what these engines read.

Microsoft has stated structured data feeds its AI. In March 2025, Fabrice Canel, Principal Product Manager at Microsoft Bing, confirmed that structured data helps Microsoft's large language models understand content for Copilot. That's one of the few on-record vendor statements about how markup feeds AI systems, and it's specific rather than speculative.

AI crawlers read it. PerplexityBot, Bingbot, and the retrieval crawlers behind various answer engines parse structured data when assembling responses. What weight each assigns to it is undocumented, and anyone claiming to know the weighting is guessing, but the markup is being read.

The honest limit of this argument: none of it is measurable in the way a rich result was. You could see a step-by-step display in Google or not see it. You cannot see whether HowTo markup made Perplexity more likely to cite your repair guide. That uncertainty is real and we're not going to paper over it. It's why we'd describe adding HowTo to new content as a reasonable low-cost bet rather than a clear win.

What to do

• Keep existing HowTo markup. No penalty, no reason to remove it, some non-Google value.
• Audit it for accuracy. Every marked-up step should be visible on the page. Remove orphaned blocks.
• Use HowToStep inside Recipe if you publish recipes: that's a supported rich result and a common miss.
• Don't expect a Google feature. It's been gone since 2023 and shows no sign of returning.
• Prioritize supported types for new implementation work: Product, Local business, Organization, Article, Recipe, Review snippet, Breadcrumb, Video, Event, Job posting.
• Ignore advice written before September 2023. A great deal of published HowTo guidance still describes the rich result as current.

AI Schema Gen generates and validates structured data across 827+ schema types, including the ones Google still rewards. Start free or browse the schema types directory, or see plans and pricing.