Schema Markup for AI Search: What Actually Works (and What’s Just Noise)

Tier 2: The Supporting Code

Article Schema

Article schema tells search engines and AI systems: this is a piece of content, here’s who wrote it, here’s when it was published and last updated, and here’s who stands behind it. If you’re publishing guides, blog posts, or any content-focused pages, every single one should have this.

Notice how the author and publisher fields reference the @id values from the Person and Organization examples above. That’s the three-layer chain (Article to Person to Organization) that gives AI systems a complete path to verify your content’s credibility.

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org”,
  “@type”: “Article”,
  “@id”: “https://yoursite.com/your-guide/#article”,
  “headline”: “Your Article Title as It Appears on the Page”,
  “description”: “A clear summary of what this article covers. 1-2 sentences.”,
  “image”: “https://yoursite.com/images/article-hero.jpg”,
  “datePublished”: “2026-02-15”,
  “dateModified”: “2026-02-28”,
  “author”: {
    “@type”: “Person”,
    “@id”: “https://yoursite.com/#person-yourname”
  },
  “publisher”: {
    “@type”: “Organization”,
    “@id”: “https://yoursite.com/#organization”
  },
  “mainEntityOfPage”: {
    “@type”: “WebPage”,
    “@id”: “https://yoursite.com/your-guide/”
  },
  “wordCount”: 4500,
  “keywords”: [“primary topic”, “secondary topic”, “related term”]
}
</script>

What to customize: The dateModified field matters more than most people realize. AI systems and search engines both use it to assess content freshness. Update it every time you make a meaningful edit. Don’t update it when you fix a typo. The wordCount field is optional but useful as a content-quality signal. The keywords field is also optional; use it if your content covers a specific topic cluster, skip it if you’d just be stuffing terms.

FAQPage Schema

FAQ schema structures your question-and-answer content in a format AI systems can extract directly. Even though Google removed FAQ rich results for most sites in 2023, the structured data still helps AI systems identify Q&A pairs on your page. The key is keeping answers concise: 40 to 60 words for optimal extraction, according to multiple sources.

One important detail: the FAQ content in your schema must be visible on the page. Don’t hide it behind accordions or tabs that AI crawlers might not expand. If it’s in your schema, it should be on the page in plain view.

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org”,
  “@type”: “FAQPage”,
  “mainEntity”: [
    {
      “@type”: “Question”,
      “name”: “What is [your topic] and why does it matter?”,
      “acceptedAnswer”: {
        “@type”: “Answer”,
        “text”: “A clear, concise answer in 40-60 words. Answer the question directly in the first sentence. Then add one or two sentences of supporting context. This format matches how AI systems extract and cite information.”
      }
    },
    {
      “@type”: “Question”,
      “name”: “How much does [your service] cost?”,
      “acceptedAnswer”: {
        “@type”: “Answer”,
        “text”: “Be specific. Ranges are fine (‘typically between $X and $Y depending on scope’) but vague answers (‘it depends on many factors’) add zero value. If you can give a real number, give a real number.”
      }
    },
    {
      “@type”: “Question”,
      “name”: “How do I know if I need [your service]?”,
      “acceptedAnswer”: {
        “@type”: “Answer”,
        “text”: “Answer with specific indicators. Not ‘if you have questions, contact us.’ Instead: ‘Three signs you need [service]: [specific sign 1], [specific sign 2], and [specific sign 3].’ Be useful, not salesy.”
      }
    }
  ]
}
</script>

What to customize: Write your FAQs based on questions your customers actually ask. Not questions you wish they’d ask. If you have a customer service team, ask them what comes up most. If you don’t, check Google’s “People Also Ask” for your main keywords, or look at your competitors’ FAQ sections. The answers should be genuinely useful. If someone reads your FAQ answer and still needs to call you to understand the basics, the answer isn’t good enough.

HowTo Schema

HowTo schema is your best friend for any step-by-step content. It maps directly to procedural queries (“how do I…” questions), which are exactly the kind of queries AI systems handle well. Each step is explicitly extractable, which means AI can pull step 3 out of your 8-step process and cite it in a response without needing to summarize your entire page.

Keep each step to 1 to 2 sentences. Number them clearly. If a step has sub-steps, nest them. The structure should be so clear that someone could follow it without reading anything else on the page.

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org”,
  “@type”: “HowTo”,
  “name”: “How to [Do the Thing Your Audience Needs]”,
  “description”: “A brief summary of what this guide walks through.”,
  “totalTime”: “PT30M”,
  “estimatedCost”: {
    “@type”: “MonetaryAmount”,
    “currency”: “USD”,
    “value”: “0”
  },
  “step”: [
    {
      “@type”: “HowToStep”,
      “position”: 1,
      “name”: “Step name (short, descriptive)”,
      “text”: “Clear instruction for this step. One or two sentences. Be specific enough that someone could do this without asking a follow-up question.”,
      “url”: “https://yoursite.com/guide/#step-1”
    },
    {
      “@type”: “HowToStep”,
      “position”: 2,
      “name”: “Next step name”,
      “text”: “The next instruction. If this step requires a tool or resource, mention it explicitly.”,
      “url”: “https://yoursite.com/guide/#step-2”
    },
    {
      “@type”: “HowToStep”,
      “position”: 3,
      “name”: “Final step name”,
      “text”: “The concluding step. If there’s a way to verify the result, include it: ‘You’ll know it worked when [observable outcome].'”,
      “url”: “https://yoursite.com/guide/#step-3”
    }
  ]
}
</script>

What to customize: The totalTime field uses ISO 8601 duration format: PT30M means 30 minutes, PT2H means 2 hours, PT1H30M means 90 minutes. Be honest about the time. If your “5-minute guide” actually takes 45 minutes, your schema is lying and people will notice. The url field on each step is optional but valuable; it lets AI systems deep-link to specific sections of your guide. Use anchor IDs (#step-1, #step-2) on your page headings to make this work.

BreadcrumbList Schema

BreadcrumbList is the simplest schema on this page and takes about two minutes to implement manually. It tells search engines where a page sits in your site hierarchy. The payoff is small but real: breadcrumb-enhanced search results give users navigational context and can improve click-through rates.

If you’re using Rank Math Pro, this is likely already generated for you. Verify it in the Rich Results Test. If not, here’s the code.

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org”,
  “@type”: “BreadcrumbList”,
  “itemListElement”: [
    {
      “@type”: “ListItem”,
      “position”: 1,
      “name”: “Home”,
      “item”: “https://yoursite.com/”
    },
    {
      “@type”: “ListItem”,
      “position”: 2,
      “name”: “Guides”,
      “item”: “https://yoursite.com/guides/”
    },
    {
      “@type”: “ListItem”,
      “position”: 3,
      “name”: “Your Guide Title”,
      “item”: “https://yoursite.com/guides/your-guide/”
    }
  ]
}
</script>

What to customize: Match your actual site hierarchy. The last item in the list is the current page. The position numbers must be sequential. If your site doesn’t have a logical hierarchy (everything is a top-level page), you probably don’t need BreadcrumbList. But if you have categories, guides, or any nested structure, this is worth the two minutes.

Putting It All Together: The Entity Chain

Here’s what makes the difference between “my site has schema” and “my site has a Content Knowledge Graph.” Look at how the @id fields connect across the examples above:

Organization (@id: yoursite.com/#organization) defines the business entity.

Person (@id: yoursite.com/#person-yourname) links to Organization via worksFor.

Article links to Person via author and to Organization via publisher.

LocalBusiness can link to Organization via parentOrganization for multi-location setups.

That’s the three-layer chain: content points to author, author points to organization. AI systems can follow these connections to verify that a real person at a real company wrote the content they’re considering citing. The Growth Marshal study found fewer than 4% of sites implement this kind of deliberate entity-linking. It’s essentially uncontested territory.

You don’t need to add all of these on day one. Start with Organization (on every page, via your site header or footer). Add Person to your About page and author bios. Add Article to every content page. Then layer in FAQPage, HowTo, and Product as the content warrants. Each piece you add strengthens the whole structure.

Then validate everything. Every page, both tools, every time. That’s the section right below this one.