How to Structure Step-by-Step Content with HowTo Schema for AI Extraction

You wrote a genuinely good tutorial. AI engines still answer the question in their own words and cite somebody else. If the question in your head right now is HowTo schema deprecated, or worth any of your time in 2026, this guide settles it and then shows you exactly what to do about it.

Here's the short version. Google retired the HowTo rich result, so no card is coming back. The markup itself still gets read, and AI engines still use it to figure out that your page holds a real procedure. By the end you'll have a working JSON-LD block, a validation routine, and an honest read on what schema can and can't do for you.

Take a breath. This is a 30-minute skill, not a project.

Step 1: Settle the deprecation question before you invest

Start here, because the answer changes how much energy you spend.

Google announced the full retirement of the HowTo rich result on desktop on September 13, 2023. The mobile version had already been phased out earlier that year. The documentation page came off Search Central shortly after, and the update log recorded that the result is no longer shown on desktop or mobile.

Nothing has reversed since. No reinstatement, no replacement rich result.

Here's the part most people miss. The schema.org HowTo type is not deprecated at the vocabulary level. It's still a valid, parseable type. Bing and DuckDuckGo still consume it for procedural snippets. ChatGPT, Perplexity, Claude, Gemini, and Google AI Mode all use it as a content-understanding and extraction signal.

So two things are true at once. You lost a Google SERP card. You did not lose the machine-readable signal that tells an engine "this page is a procedure, and here are its steps in order."

How to tell this step is done: you can say in one sentence what you expect from HowTo structured data. No Google card. Still parsed and indexed. Still used by Bing and by AI engines.

Where people go wrong: reading "retired rich result" as "delete the markup." Those are different claims. One is about a visual feature in Google's results. The other is about whether machines can parse your steps, and they still can.

Step 2: Decide whether your page actually deserves HowTo markup

Not every page earns this. Being honest here saves you from the single most common failure.

Add HowTo when your page describes a real, ordered procedure the reader can execute. Each step should produce a discrete, demonstrable outcome. You should be able to list real supplies and tools, or honestly say there are none. Ideally you have unique imagery per step and can estimate a credible total time.

Skip HowTo when the page is an essay, an opinion piece, or a thought piece. Skip it for comparisons and listicles with no executable sequence. Skip it when the steps are abstract, the "understand your audience" and "consider your goals" kind. Skip it on a one-action page like "how to contact support," where a ContactPage or FAQPage fits better.

Recipes are their own thing. Cooking content belongs to the Recipe type, which has its own rich-result eligibility. HowTo covers non-recipe procedures: bike maintenance, software setup, tax filing.

Here's the rule of thumb worth memorizing. If the page wouldn't work as a numbered checklist you could print and execute, it doesn't deserve HowTo markup.

Common mistake: bolting tutorial schema onto a listicle because it has numbers in it. Google's structured data policy disqualifies markup that isn't visibly reflected in the page content. A "7 best tools" post has numbers, not steps. Marking it up as a procedure is a policy problem, not a clever shortcut.

How to tell this step is done: you've made a yes or no call, and if it's no, you closed the tab and moved on guilt-free. That's a real win. You just saved an hour.

Step 3: Rewrite the steps so an extractor can lift them

This is the step people skip, and it's the one that actually decides whether you get quoted.

Markup describes your content. It doesn't fix it. If your steps are mushy prose, an engine can parse the JSON-LD perfectly and still find nothing worth lifting. So before you write a line of code, fix the words.

Extractors want seven things from each step:

1. Self-contained sentences. No "this," "that," or "it" pointing back at earlier context. A step lifted out of your page has to still make sense.
2. Imperative voice. "Press the brake pedal," not "the brake pedal should be pressed."
3. One action per step. If your step has an "and then" in it, it's two steps.
4. Numbered headings in H2 or H3 that mirror the position values in your markup.
5. Per-step images that actually differ from each other.
6. Anchor URLs like #step-3, so an extractor can point at one specific step.
7. A concise summary of 40 to 60 words above the steps, so the engine gets the whole procedure in one bite.

Read your draft against that list. Most tutorials fail on one and two, and both are quick fixes. Rewriting eight mushy steps into eight liftable ones takes maybe twenty minutes, and it improves the page for humans at the same time.

That's the real work behind step schema for AI extraction. The JSON-LD is just a label. The self-contained, imperative, one-action step is the thing being labeled.

How to tell this step is done: you can copy any single step out of the page, paste it somewhere with no context, and it still reads as a complete instruction.

Step 4: Build the HowTo JSON-LD block

Now the code. It's less than you think.

At the top level, HowTo is a subtype of CreativeWork, so it inherits author, datePublished, image, publisher, and the rest.

Two properties are required:

• name: the title of the how-to.
• step: an ordered array of steps. Wrap it in an array even when there's only one.

These are recommended, and each one adds context an engine can use:

• description: a sentence or two summarizing the process.
• image: at least one crawlable image, with 1200 px wide as the practical floor.
• totalTime: an ISO 8601 duration.
• estimatedCost: a MonetaryAmount or free text.
• supply: things consumed. tool: things used but not consumed.
• yield, prepTime, performTime: what it produces, and the time before and during.

Each step is a HowToStep. It requires name plus text. It recommends position (an integer starting at 1), image, url, video, performTime, and tip.

A few subtypes are worth knowing. HowToSection groups steps into phases, carrying its own name, position, and nested steps. Only reach for it when your tutorial genuinely has phases, and don't nest for the sake of nesting. HowToTip attaches a tip to a step. HowToSupply and HowToTool let you attach quantities and costs instead of bare text. HowToDirection is for compass bearings in navigation how-tos, which is probably not you.

Durations trip everyone up, so keep this nearby: PT15M is 15 minutes, PT1H30M is an hour and a half, PT45S is 45 seconds, P1D is a day, P1DT2H is a day and two hours. A duration needs at least one time component after the P or PT, so P0Y is invalid.

Here's a fully populated block to model yours on. Drop it into a single <script type="application/ld+json"> in the head or at the end of the body.

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Change a Flat Tire",
  "description": "Step-by-step instructions for safely changing a flat tire on a passenger vehicle.",
  "image": ["https://example.com/flat-tire-hero.jpg"],
  "totalTime": "PT30M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": "0"
  },
  "supply": [
    { "@type": "HowToSupply", "name": "Spare tire" },
    { "@type": "HowToSupply", "name": "Vehicle owner's manual" }
  ],
  "tool": [
    { "@type": "HowToTool", "name": "Lug wrench" },
    { "@type": "HowToTool", "name": "Car jack" },
    { "@type": "HowToTool", "name": "Wheel chock" }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Find a safe location",
      "text": "Pull over to a flat, stable surface away from traffic. Engage the hazard lights and the parking brake. Place a wheel chock on the diagonal tire.",
      "image": "https://example.com/step1.jpg",
      "url": "https://example.com/change-tire#step1"
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Loosen the lug nuts",
      "text": "Using the lug wrench, turn each lug nut one half-turn counter-clockwise. Do not remove them yet.",
      "image": "https://example.com/step2.jpg",
      "url": "https://example.com/change-tire#step2",
      "tip": {
        "@type": "HowToTip",
        "text": "Loosen while the tire is still on the ground for more torque."
      }
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Jack up the vehicle",
      "text": "Place the jack under the manufacturer's recommended lift point. Raise the vehicle until the flat tire is fully off the ground.",
      "image": "https://example.com/step3.jpg",
      "url": "https://example.com/change-tire#step3"
    }
  ]
}

Notice how little of that is exotic. Name, steps, times, tools, and a tip.

If hand-authoring JSON-LD for every tutorial sounds like the thing that quietly never happens, that's a fair worry, and it's why schema markup belongs in the writing pipeline rather than in a cleanup pass afterward. DeepSmith builds schema, heading structure, internal links, and metadata during article creation, so the markup ships with the piece instead of waiting on a ticket.

How to tell this step is done: your JSON parses, every step has a name and text, and the positions run 1, 2, 3 with no gaps.

Step 5: Wire each step to its own anchor and image

Two small details separate markup that merely validates from markup an engine can cite precisely.

First, give every step an anchor URL. Add an id to the step's heading on the page, then point the step's url at it. Now an extractor can cite step three specifically rather than your whole article.

Second, give every step its own image. The spec doesn't require it. Extraction quality improves anyway, and per-step imagery is a quality signal that separates a real tutorial from a thin one. Each step's image should differ from the top-level image and from its siblings.

Common mistake: five of them cluster here, and they're all cheap to avoid.

• Relative URLs. Every image, url, and video must be absolute, starting with https://.
• position as a string. Write 1, not "1". Validators flag it, and some AI extractors silently drop your ordering.
• The same stock photo on every step. One generic image repeated seven times is worse than none.
• One mega-step holding the whole procedure. Each action needs its own step, or you've labeled a wall of text as a wall of text.
• Steps with text but no name. They parse. They also extract worse, because the engine has no short handle for the step.

How to tell this step is done: click each step's anchor URL and land on that exact step. Every image URL opens on its own.

Step 6: Choose your implementation path

You don't have to hand-code any of this. Pick the path that matches your stack.

On WordPress, several plugins handle tutorial schema natively. Rank Math offers a dedicated HowTo block and a JSON-LD generator, free, with Pro from around $59 a year. Yoast supports HowTo through its schema blocks, free, with Premium around $99 a year. Schema Pro treats HowTo as a first-class type with field mapping at $79 a year or $249 lifetime. AIOSEO offers schema templates and custom rules, with a free tier and Elite around $299 a year. The standalone Schema plugin does lightweight automatic markup with minimal overhead.

Off WordPress, you have options too. Any tag manager, GTM or Tealium, can inject JSON-LD. Headless CMS users on Contentful, Sanity, or Strapi should render JSON-LD server-side through templating. Static-site generators like Astro, Next.js, and Hugo emit it from templates.

Pro tip: whichever path you pick, the plugin only fills in the fields you feed it. Garbage steps in, garbage markup out. Step 3 is still the work.

How to tell this step is done: you can add HowTo structured data to a new tutorial in under five minutes without opening a code editor.

Step 7: Validate before you publish, then re-check quarterly

Four checks, and none of them take long.

1. Check the JSON syntax locally first. A single trailing comma breaks parsers.
2. Paste it into the Schema Markup Validator at validator.schema.org. It's the canonical validator that replaced Google's retired Structured Data Testing Tool, and it validates against schema.org regardless of Google's own rich-result eligibility.
3. Optionally run the Rich Results Test. For HowTo it returns a non-error response acknowledging the type, without a preview, because no HowTo rich result exists anymore. That's the expected result, not a failure. Use it to confirm Google parses your JSON-LD cleanly.
4. View source on the rendered page. Confirm the ld+json script is in the HTML the server returns, not injected later by client-side JavaScript. Most crawlers don't execute JS for structured data, so JS-injected markup is often invisible to the engines you're trying to reach.

Then put a quarterly reminder on the calendar. Schema breaks silently during redesigns. Nothing tells you. The markup just quietly stops describing the page.

How to tell this step is done: the validator returns no errors, and you found your JSON-LD in view-source, not just in the browser inspector.

Step 8: Measure whether AI actually quotes your steps

Last one, and it's the one that keeps you honest.

Let's be straight about the evidence, because the internet is not. One 2026 vendor benchmark tested over a thousand query-response pairs across ChatGPT, Perplexity, and Claude, and found pages with valid JSON-LD were cited more often than unmarked equivalents, with HowTo among the types showing a meaningful lift. It's a single-vendor study. Treat it as directional, not as physics.

Pull the other way too. A 2026 working paper looking inside Google's own index found that schema was about as common on AI-cited pages as on comparable pages that weren't cited at all. Read together, those two results tell a consistent story: schema helps engines extract your content, but it doesn't win the citation by itself.

So here's the honest framing. Schema is an extraction aid, not a ranking shortcut. It lowers the cost for an AI system to identify and quote your steps. It doesn't guarantee anything, and the lift varies by engine and by content type.

Which means the only way to know is to watch. Track the prompts your buyers actually ask, then check whether your tutorial gets mentioned or cited, and on which engine. DeepSmith tracks mention and citation rates across ChatGPT, Perplexity, Gemini, Claude, and Google AI Mode, and shows which of your pages earn the citations, so you can tell whether step schema for AI extraction moved anything on the pages you marked up.

How to tell this step is done: you have a baseline. You know what your citation rate looked like before the markup, so the after means something.

What to do next

Pick your single best tutorial. Not the whole library, just one.

Run it through step 2 and confirm it truly is a procedure. Fix the steps against the seven-point list in step 3. Add the JSON-LD. Validate it. That's your afternoon, and it's enough to learn whether this is worth repeating across the rest of your content.

Then do the next one next week. Momentum matters more than a big-bang rollout.

If the part you're dreading is doing this by hand on every article forever, that's the part worth automating. Start a free DeepSmith trial and see what publish-ready looks like when schema, links, and metadata come built in.