Should I use HowTo schema or Article schema on my posts?

What makes HowTo schema structurally different from Article schema?

The difference isn't just semantic. It's structural. HowTo and Article schema have different required properties, and those properties reflect what kind of content they're designed to classify.

HowTo schema requires a step array. Each step has a name and text. And optionally an image. The schema is designed to represent a sequence of discrete actions. Without a step array, HowTo markup is incomplete and invalid. The structure forces you to think of your content as numbered procedural steps that someone would actually follow.[1]

// HowTo schema. Minimal valid example
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to add FAQ schema to a custom HTML page",
  "description": "Step-by-step instructions for adding FAQPage schema...",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Open your HTML file",
      "text": "Open the HTML file for the page you want to add schema to."
    },
    {
      "@type": "HowToStep",
      "name": "Add the script tag",
      "text": "Inside the head element, add a script tag with type='application/ld+json'."
    }
  ]
}

Article schema (and BlogPosting) require headline and author. The structure is built around a piece of writing with an identified expert author, not a sequence of steps. The schema says: this is content, it was written by a specific person, it was published on a specific date.[2]

The mental test: could your reader summarize the content as "do Step 1, then Step 2, then Step 3"? That's HowTo. Could they summarize it as "this expert explains what X means and how it works"? That's BlogPosting.

When should I actually use HowTo schema?

HowTo schema is appropriate for a narrower category of content than most people realize. The test isn't whether your post title starts with "How to". It's whether the body of the post is organized as a sequential, procedural set of numbered steps that a reader follows in order.

Content that fits HowTo schema:

• "How to set up Google Search Console in 6 steps". With actual numbered setup steps
• "How to install JSON-LD schema on a WordPress site". With discrete technical steps
• "How to conduct an AI visibility audit of your website". If genuinely structured as a numbered checklist

Content that does not fit HowTo schema, despite having "how to" in the title:

• "How to build authority online". This is analysis and strategy, not a numbered procedure
• "How AI decides who to recommend". This is explanation, not instruction
• "How to think about schema markup for your business". This is conceptual guidance

The latter category belongs in BlogPosting schema. The title is irrelevant. The structure determines the type.[3]

What AI signal does each schema type send?

Schema type is one of the fastest classification signals AI engines process. Before reading a single word of your content, an AI crawler that detects HowTo schema knows: this page is structured as step-by-step instruction. One that detects BlogPosting knows: this is dated writing by a named author.

Schema Type	AI Classification Signal	Best Content Format	Authority Signal Strength for Sites
HowTo	"This page teaches a procedure"	Numbered step sequences	Moderate. Procedural, not personally voiced
Article	"This page contains authored content"	General editorial writing	Good. But generic
BlogPosting	"This is a dated post by a named author"	Expert Q&A, analysis, opinion	Strong. Specific, dated, authored

For most authority directory nodes, the BlogPosting classification is more valuable than HowTo because it establishes authorship, establishes a publication date, and signals that this is a piece of perspective. Not just a procedural walkthrough that any competent person could write.

What does the HowTo schema code actually look like, and how does it differ from BlogPosting?

The structural difference is clearest when you look at both schemas side by side. The core distinction: HowTo has steps; BlogPosting has author and publication date.

// BlogPosting schema. For an expert Q&A node
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "What is the difference between HowTo schema and Article schema?",
  "description": "HowTo classifies procedural content; Article classifies knowledge.",
  "url": "https://yourdomain.com/your-page",
  "datePublished": "2026-03-18",
  "dateModified": "2026-03-18",
  "author": {
    "@type": "Person",
    "name": "Your Name",
    "url": "https://yoursite.com",
    "sameAs": ["https://linkedin.com/in/yourprofile"]
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Business",
    "url": "https://yoursite.com"
  }
}

The BlogPosting schema has no step array. It has author identity, publication date, and a headline that matches the H1. This combination tells AI: here is an expert, here is what they wrote, here is when they wrote it. That's the authority signal. And it's the one most relevant to getting recommended.[4]

Should I ever use HowTo schema on an authority directory node?

Rarely. But yes, in specific cases. If you're building a node that genuinely answers a procedural question (for example, "How do I add schema markup to a custom HTML website?") and the answer is best delivered as a numbered sequence of technical steps, HowTo schema is correct.

The practical test for authority directory nodes: is the primary content type knowledge or instruction?

• Knowledge content (what it is, why it matters, how to think about it) → BlogPosting
• Instruction content (the specific steps to follow to accomplish a task) → HowTo

Most authority directory nodes are knowledge content. They answer "what is X," "why does X matter," "how does X work," and "what should I do about X." These are all BlogPosting territory. The exception would be a node that answers a genuinely procedural query. And for those, HowTo is both correct and appropriate.

When in doubt: if you're answering a question with explanation and analysis, use BlogPosting. If you're answering a question with numbered steps, use HowTo.