← ClickRadius Institute

HowTo and Recipe Schema for AI Answer Engines

Published April 28, 2026 · ClickRadius Institute

Procedural content — how to unclog a drain, how to braise short ribs, how to reset a router — is exactly the shape AI answer engines love to reproduce: a clean, ordered list of steps a user can follow without leaving the answer. HowTo and Recipe schema are the vocabularies that describe procedures to a machine. There is a wrinkle worth being honest about up front: Google deprecated the generic HowTo rich result in 2023, so the markup no longer buys a special search appearance. But the reason to use it has shifted rather than disappeared. This guide explains that shift, shows the code for both types, and covers the honesty rules that keep procedural markup from backfiring.

The deprecation, stated plainly

Let's not bury it. In 2023, Google announced it was retiring the HowTo rich result — the visual step-by-step treatment that could appear in search — for most users, and reduced Recipe and other features around the same period as it simplified search appearances. According to Google's HowTo structured data documentation, the HowTo rich result is deprecated and Google no longer shows it. If your only goal was the rich result, that goal is gone, and any article that tells you HowTo markup will earn you a fancy search box is out of date.

So why is this guide recommending it anyway? Because structured data was never only about rich results. It is a machine-readable description of what your page contains, and the audience for that description has grown well beyond Google's search-appearance team.

A deprecated rich result means the decoration went away. The description did not. Markup that reliably tells a machine "these are the ordered steps, these are the tools, this is the total time" is more useful in an answer-engine world than it ever was as a carousel.— ClickRadius Institute analysis

Why procedural markup still helps AI comprehension

AI answer engines reproduce procedures constantly. When an assistant answers "how do I descale my espresso machine," it is assembling an ordered list — and it would prefer to assemble it from a source where the steps are unambiguously delimited rather than inferred from flowing paragraphs. Schema is the most explicit way to say "step 1 ends here, step 2 begins here, this sentence is a tool and not an instruction."

Two honest caveats keep this in proportion. First, modern language models are good at parsing well-structured HTML on their own; a page with clean numbered headings and an ordered list is already highly extractable, markup or not. Second, no one outside Google publishes a guarantee that a given engine reads HowTo JSON-LD. So the correct framing is comprehension insurance: the markup costs little, it removes ambiguity, and it makes your procedure the easiest one in the candidate set to lift cleanly. When an engine is choosing which of five tutorials to reproduce, "the one I can parse without error" is a real advantage. That is the same logic behind treating structure as a citation signal, which we cover in Content Formats AI Engines Prefer.

The scale of the opportunity is worth stating. Industry trackers estimated roughly 60% of searches ended without a click by 2024, and AI answer surfaces expanded rapidly through early 2026 — meaning more procedural queries get answered in place. Being the maximally-extractable source for a common "how to" is a durable position, because procedures change slowly and the well-marked-up version keeps getting reused.

HowTo schema: steps, supplies, tools

The HowTo type describes a general procedure. Its core properties are step (an ordered list of HowToStep nodes), supply (consumables you use up), and tool (instruments you keep). Optional totalTime uses ISO 8601 duration format. Here is a complete, honest example:

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to Descale a Home Espresso Machine",
  "totalTime": "PT30M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "USD",
    "value": "8"
  },
  "supply": [
    { "@type": "HowToSupply", "name": "Citric-acid descaling solution" },
    { "@type": "HowToSupply", "name": "Fresh water" }
  ],
  "tool": [
    { "@type": "HowToTool", "name": "Empty carafe or jug" }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "Prepare the solution",
      "text": "Fill the water tank with fresh water and add the descaling solution per the product ratio.",
      "url": "https://example.com/descale#step1"
    },
    {
      "@type": "HowToStep",
      "name": "Run the descale cycle",
      "text": "Place the carafe under the group head and run water through until the tank is nearly empty.",
      "url": "https://example.com/descale#step2"
    },
    {
      "@type": "HowToStep",
      "name": "Rinse thoroughly",
      "text": "Refill with plain water and run two full tanks through to clear all solution.",
      "url": "https://example.com/descale#step3"
    }
  ]
}

Each HowToStep should carry a short name and a full text, and ideally a url with a fragment anchor that deep-links to that step on the page. The supply/tool split matters for comprehension: it tells a machine what a follower needs to gather before starting, which is exactly the "what you'll need" section an assistant often surfaces first. Note that the markup here mirrors the article precisely — three steps in the JSON because there are three steps on the page. That fidelity is not optional, as the honesty section below explains.

HowToSection for longer procedures

For multi-part procedures, HowToSection groups steps under sub-headings (for example "Preparation," "Assembly," "Finishing"), each containing its own step array. This preserves the two-level structure of a complex guide so a machine can reproduce it with its natural hierarchy intact rather than flattening twenty steps into one undifferentiated list.

Recipe schema: the food-specific procedure

Recipe is HowTo's specialized cousin for food, and unlike the generic HowTo result, Recipe rich results are still supported by Google. According to Google's Recipe structured data documentation, valid Recipe markup can still be eligible for recipe rich results and host-specific carousels. That makes Recipe a rare case where both the search-appearance benefit and the AI-comprehension benefit are live at once. Its dedicated properties are richer and more precise than HowTo's:

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Weeknight Braised Short Ribs",
  "author": { "@type": "Organization", "name": "Example Kitchen" },
  "datePublished": "2026-04-28",
  "prepTime": "PT20M",
  "cookTime": "PT2H30M",
  "totalTime": "PT2H50M",
  "recipeYield": "4 servings",
  "recipeIngredient": [
    "1.5 kg bone-in beef short ribs",
    "2 tbsp neutral oil",
    "1 large onion, diced",
    "500 ml beef stock"
  ],
  "recipeInstructions": [
    { "@type": "HowToStep", "text": "Sear the ribs on all sides in the oil over high heat." },
    { "@type": "HowToStep", "text": "Soften the onion, then add stock and the seared ribs." },
    { "@type": "HowToStep", "text": "Cover and braise at 160C for about 2.5 hours until tender." }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "540 calories",
    "proteinContent": "38 g"
  }
}

The key craftsmanship point: model recipeInstructions as an array of HowToStep objects, not a single paragraph. Individually delimited steps are what let an assistant reproduce the method as a clean numbered list, and what let it answer "how long does the braise take" from cookTime directly. A recipe dumped into one text field forces the machine to re-segment your prose, introducing exactly the ambiguity structured data exists to remove.

How procedural markup maps to an AI step-by-step

The mapping is nearly one-to-one, which is why these types reward the effort. Consider what an assistant needs to answer a procedural question well, and where each need is satisfied:

  1. An ordered sequence → the step / recipeInstructions array, in document order.
  2. A gather-first list → supply + tool, or recipeIngredient.
  3. A time expectation → totalTime / cookTime, machine-readable as a duration.
  4. A yield or outcome → recipeYield, or the HowTo's name stated as a goal.

When those four are all cleanly labeled, an engine can reconstruct your entire procedure with its structure and metadata intact — and it can answer follow-ups ("what do I need?", "how long?") without re-reading the whole page. That is the difference between being a source a machine can use and a source a machine prefers to use because you did the segmentation work for it.

The best procedural content does the machine's parsing for it. You are not marking up steps to win a badge; you are handing the engine a pre-segmented, pre-labeled procedure so that when it needs one, yours is the path of least resistance.— ClickRadius Institute analysis

The honesty rules for procedures

Procedural markup has its own version of the trust rule that governs all structured data: it must faithfully describe the visible page. According to Google's structured data general guidelines, marked-up content must be present on the page and represent it accurately. For procedures that means:

The reason to care is not only policy. AI answer engines that reproduce your procedure are staking a small piece of their own credibility on your accuracy. Feed them a fabricated step and you produce a wrong answer with your name on it — the fastest way to stop being reused. Faithful markup is both the compliant choice and the strategically correct one.

Implementation checklist

  1. Use Recipe for food (still rich-result eligible) and HowTo for all other procedures (rich result deprecated, comprehension value intact).
  2. Model steps as individual HowToStep nodes — never one paragraph — each with name, text, and ideally a fragment url.
  3. Include the gather-first list: supply/tool or recipeIngredient, matching the page exactly.
  4. Provide honest durations in ISO 8601 (PT30M, PT2H30M) and, for recipes, recipeYield and nutrition if stated.
  5. Keep well-structured on-page HTML — numbered headings and ordered lists — because that is what most systems read regardless of the JSON.
  6. Validate with the Schema.org validator, and use Google's Rich Results Test for Recipe eligibility specifically.

Frequently asked questions

If Google deprecated HowTo rich results, is HowTo schema still worth adding?

Yes, for a different reason than before. Google retired the HowTo rich result in 2023, so the markup no longer earns a special visual treatment in search. But structured data is not only for rich results — it is a machine-readable description of your content. Clean HowTo markup still labels your steps, tools and supplies unambiguously, which helps AI answer engines extract an accurate step-by-step. Treat it as comprehension insurance rather than a guaranteed appearance, and make sure the on-page HTML is well structured too, because that is what most systems read regardless.

What is the difference between HowTo and Recipe schema?

Recipe is a specialized procedural type for food, with dedicated properties like recipeIngredient, recipeInstructions, cookTime, prepTime, recipeYield and nutrition. HowTo is the general-purpose procedure type for everything else — repairs, setup, crafts — using step, supply and tool. Recipe rich results are still supported by Google, whereas the generic HowTo rich result was deprecated. Use Recipe for food and HowTo for non-food procedures; do not force a repair guide into Recipe markup.

Can procedural markup fabricate steps or times my content doesn't actually contain?

No. Google requires that structured data reflect the visible content of the page. Every step, ingredient, tool, cook time and yield in the markup must be genuinely present in the article. Inventing steps to look more thorough, or padding cook times, is a structured-data quality violation and also misleads the AI systems reading it. The markup should be a faithful, labeled copy of what a human reader sees, never an embellishment of it.

ClickRadius checks whether your procedural content is structured for machine extraction — clean steps, honest times, faithful markup — as part of its six-category AI-citation score, and can generate GEO-optimized content that reads well for both humans and answer engines. Get your free AI Readiness Score, or see plans on the pricing page.

Related from the Institute