HowTo Schema for AI Citation: The Complete 2026 Implementation Guide

HowTo schema is the Schema.org type that encodes a step-by-step procedure in machine-readable format. When a user asks an AI engine "how do I do X", the retrieval system looks for pages that have explicitly structured their answer as an ordered sequence of steps - and HowTo schema is the direct signal that a page has done exactly that. Pages with valid HowTo schema are cited in procedural AI answers at a significantly higher rate than pages that describe the same steps in unstructured prose.

Alongside FAQPage schema, HowTo is one of the two highest-impact structured data types for AI citation. Where FAQPage tells an AI engine "this page authoritatively answers these questions", HowTo tells it "this page explains exactly how to complete this task, step by step". The two types are complementary and can coexist on the same page.

How AI engines process HowTo schema

When a retrieval-augmented generation (RAG) system processes a procedural query, it prioritises content that maps directly to an ordered sequence. Unstructured prose describing a process is harder to extract reliably than explicit step objects. HowTo schema removes that ambiguity: the retrieval system can parse step names, descriptions, and ordering directly from the JSON-LD without text processing heuristics.

• ChatGPT Search: uses HowTo step names as the basis for bulleted steps in "how to" responses - matching your step names to query phrasing improves citation rate
• Perplexity: renders numbered steps directly from structured data when it detects HowTo schema on a retrieved page, reducing hallucination risk for procedural content
• Google AI Overviews: HowTo schema is a primary signal for step-by-step AI Overview panels - the same markup that earns rich results in organic search also drives AI Overview citations
• Claude: retrieves the full step text as passage-level content - longer, self-contained step descriptions perform better than terse labels

The basic HowTo JSON-LD structure

The minimum viable HowTo schema requires a name (the procedure title), a description (what the procedure accomplishes), and an array of HowToStep objects. Each step needs at least a name and a text property. The totalTime property is optional but recommended - it appears in rich result previews and signals procedural scope to AI engines.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to add llms.txt to a Next.js site",
  "description": "Create and deploy an llms.txt file on a Next.js App Router project to improve AI crawler access.",
  "totalTime": "PT15M",
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "Create the route file",
      "text": "In your app directory, create app/llms.txt/route.ts. This file exports a GET handler that returns your llms.txt content as plain text with content-type text/plain."
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "Write the llms.txt content",
      "text": "Open with a # heading containing your site name, a > blockquote describing what your site does, then sections with markdown-format links to your key pages and blog posts."
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Validate with Rich Results Test",
      "text": "Paste your deployed URL into the Google Rich Results Test and confirm the HowTo type is detected with all steps and their text parsed correctly."
    }
  ]
}
</script>

Implementation in Next.js (App Router)

In Next.js App Router, inject HowTo schema as a JSON-LD script tag directly in your page or layout component. Derive the step data from your content model rather than hardcoding it separately - if your visible steps and your schema steps are defined in two places, they will eventually drift apart, which is a quality signal violation.

interface HowToStep {
  position: number;
  name: string;
  text: string;
}

function HowToSchema({
  title,
  description,
  steps,
}: {
  title: string;
  description: string;
  steps: HowToStep[];
}) {
  const schema = {
    '@context': 'https://schema.org',
    '@type': 'HowTo',
    name: title,
    description,
    step: steps.map((s) => ({
      '@type': 'HowToStep',
      position: s.position,
      name: s.name,
      text: s.text,
    })),
  };
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

Implementation in WordPress and plain HTML

For non-Next.js stacks, the implementation path depends on your CMS. WordPress has plugin support that makes HowTo schema straightforward to add without writing JSON manually. For plain HTML sites, the JSON-LD block can be pasted directly into the page head with no framework required.

• Yoast SEO: use the Gutenberg HowTo block in the post editor - Yoast generates and injects the JSON-LD schema automatically from the block content
• Rank Math: open the Schema tab in any post, select HowTo, and fill in the step fields directly in the UI with no manual JSON required
• Plain HTML: copy the JSON-LD structure above and paste it into a script tag in your page head; update the step content to match your visible steps
• Custom CMS: store step data in structured fields (step name, step text, position) and template the JSON-LD at render time to keep schema and visible content in sync

Writing HowTo steps that AI engines prefer

The content of each step matters as much as the markup. AI retrieval systems evaluate step quality, not just step presence. Weak step descriptions reduce citation confidence even when the schema is technically valid and all required fields are present.

• Start each step name with an imperative verb: "Create the file", "Add the script tag" - not "Step 1" or "The file creation stage"
• Write step text as a self-contained instruction: a reader should be able to act on the step without reading the surrounding context
• Include the outcome in the step text: "This creates a public-facing route that AI crawlers fetch at your root domain" tells the engine what completing the step achieves
• Keep step text between 40-120 words - enough to be useful as a cited passage, short enough to fit within an AI citation window
• Use consistent terminology across step names and step text: if you call something a "route file" in step 1, do not rename it a "handler" in step 3
• Avoid parenthetical asides and inline caveats inside step text - move these to a separate callout or FAQ item so steps stay scannable

Combining HowTo and FAQPage schema on one page

For pages that explain both a procedure and answer common questions about it - a tutorial post, a how-to guide with a Q and A section - adding both HowTo and FAQPage schema in a single JSON-LD block is valid and recommended. The two types address different query surfaces: HowTo captures "how do I" queries, FAQPage captures "what is" and "why" queries. A tutorial page with both types effectively doubles its citation surface area compared with a page that uses only one schema type.

Validating your HowTo schema before publishing

Always validate before deploying. Invalid schema is worse than no schema - malformed JSON-LD can confuse crawlers and reduce overall structured data trust for your entire domain, affecting pages beyond the one with the error.

• Google Rich Results Test (search.google.com/test/rich-results): paste your URL or code snippet to check HowTo eligibility and preview how steps render in search results
• Schema.org validator (validator.schema.org): checks for specification compliance beyond Google-specific requirements and flags deprecated or missing properties
• CiteRank audit: checks for HowTo schema presence and basic validity alongside all other AEO signals in a single pass