Schema Markup for AI Search

Structured data has always been a signal layer on top of your content - a way of telling search engines what things mean, not just what words appear on the page. For traditional search, schema markup was useful but rarely decisive. For AI search, it is close to essential.

When a language model generates an answer and decides which sources to cite, it is not crawling your page in real time. It is working from a compressed, semantic understanding of the web - built during training, supplemented in some systems by retrieval-augmented generation (RAG) at query time. Schema markup is one of the most reliable ways to insert clean, unambiguous, machine-readable facts into that understanding. It reduces the cognitive load on the model: instead of inferring what your organisation does, who wrote your article, or whether your product has strong reviews, the model can read it directly from structured data.

This guide is written for SEO professionals who understand the mechanics of schema markup. It focuses specifically on the types and implementation patterns that send the strongest signals to AI models - not just to Google's rich results.

Why Schema Markup Matters for AI Citation
JSON-LD vs Microdata: Always Use JSON-LD
The 8 Schema Types That Matter Most for AI
Implementing Article Schema
Implementing FAQPage Schema
Implementing Organisation Schema
The dateModified Signal: Why Freshness Matters
Validating Your Schema Markup
Schema for SaaS Products: A Complete Example
Common Mistakes That Hurt More Than Help
Prioritising: What to Implement First
Frequently Asked Questions

Why Schema Markup Matters for AI Citation

Traditional search engines rank pages. AI search engines cite sources. The distinction matters enormously for how you approach structured data.

When Google ranks a page, it is making a probabilistic judgement about relevance and authority based on hundreds of signals. Schema markup improves your chances at the margins - it can unlock rich results, clarify entity relationships, and strengthen topical authority signals.

When an AI model decides to cite a source, it is making a more brittle, confidence-based decision. The model will cite a page if it is confident that the page is authoritative, current, and directly relevant to the query. Ambiguity hurts you. If the model has to guess whether you are a brand or a product, whether your article was published last month or five years ago, or whether your review data is genuine or marketing copy, it will often default to a cleaner source.

Schema markup eliminates that ambiguity. It states facts in a format that models are trained to trust - because schema.org vocabulary is consistent, well-documented, and used by billions of pages. When your page declares "@type": "Article" with a clearly named author, a specific datePublished, and a well-formed publisher block pointing to your organisation, you are not hoping the model will infer those facts. You are stating them.

There is a second reason schema matters for AI search: retrieval-augmented generation. Systems like Perplexity, ChatGPT with browsing, and Claude with web access retrieve pages at query time and extract facts to include in answers. Structured data makes extraction dramatically more reliable. A RAG system parsing your FAQPage schema can pull a clean question-answer pair directly from the JSON-LD block - it does not need to parse your prose, identify the question boundary, and hope the answer is in the next paragraph.

The net effect is straightforward: pages with clean, complete, accurate schema markup are cited more often, cited more accurately, and cited with higher confidence.

JSON-LD vs Microdata: Always Use JSON-LD

There are three ways to embed schema markup in a page: JSON-LD (JavaScript Object Notation for Linked Data), Microdata, and RDFa. The answer for AI search is unambiguous - use JSON-LD, always.

Why JSON-LD wins:

It lives in a <script> tag in your <head>, completely separate from your HTML markup. This means it is easy to read, easy to update, and not entangled with your visual design.
It can be injected dynamically by JavaScript without touching the DOM - essential for CMS-driven sites and headless architectures.
It is Google's recommended format, which means it is what model training data overwhelmingly reflects.
It is far easier to validate and audit at scale. You can extract every JSON-LD block from a crawl with a simple script.
AI systems that parse structured data at retrieval time find JSON-LD blocks trivially - they are in <script type="application/ld+json"> tags and do not require DOM traversal.

Microdata embeds attributes directly in your HTML elements (itemscope, itemtype, itemprop). It works, but it couples your structured data to your HTML structure - making both harder to maintain. RDFa has similar issues. Neither offers meaningful advantages over JSON-LD for any modern use case.

If you have legacy Microdata on a site, migrating to JSON-LD is worth the engineering time. It will not break your existing rich results, and the maintainability improvement alone justifies it.

The 8 Schema Types That Matter Most for AI

Not all schema types carry equal weight for AI citation. These eight are the ones that most directly affect whether and how AI models understand, trust, and cite your content.

1. Article / BlogPosting

The most important schema type for content pages. It establishes who wrote the content, when it was published, who published it, and what the headline is - exactly the provenance signals AI models use to assess authority and freshness. BlogPosting is a subtype of Article; use it for blog-format content and Article for more formal editorial content.

2. FAQPage

One of the highest-impact schema types for AI citation. FAQPage schema structures your content as explicit question-answer pairs - precisely the format AI models use when generating answers. A well-implemented FAQPage block can be lifted almost verbatim into an AI response.

3. HowTo

For step-by-step instructional content, HowTo schema signals that your page contains procedural knowledge. AI models frequently generate "how to" answers, and a clearly marked HowTo block - with named steps and optional images - is highly citable.

4. Organisation

The entity anchor for your brand. Organisation schema establishes your brand as a named entity with a consistent identity - name, URL, logo, social profiles, contact information. This is the schema that tells AI models "this is a real, identifiable organisation," which flows through to how your other content is attributed.

5. Product / SoftwareApplication

For product pages and SaaS tools, Product and SoftwareApplication schemas carry your offering's key facts: name, description, pricing, rating, features. AI models answering "what is the best tool for X" queries rely heavily on these signals.

6. WebSite

Often overlooked, WebSite schema with a SearchAction block tells models what your site is, what it does, and how to query it. It reinforces the relationship between your domain and your brand entity.

7. BreadcrumbList

BreadcrumbList schema is underrated for AI purposes. It establishes the topical hierarchy of a page - telling the model not just what the page is about, but where it sits in the architecture of your knowledge. A page on "Python decorators" that sits under /docs/python/advanced/ is contextually different from the same page sitting under /blog/.

8. Review / AggregateRating

Social proof is a trust signal for AI models, just as it is for humans. AggregateRating schema attached to a Product or SoftwareApplication can be the deciding factor in whether an AI recommends your tool over a competitor.

Implementing Article Schema

The Article schema is the workhorse of content-based AI visibility. Here is a complete, production-ready example:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema Markup for AI Search: A Complete Guide",
  "description": "A technical guide covering the structured data types that send the strongest signals to AI models - written for SEO professionals.",
  "image": {
    "@type": "ImageObject",
    "url": "https://example.com/images/schema-ai-search-guide.jpg",
    "width": 1200,
    "height": 630
  },
  "author": {
    "@type": "Person",
    "name": "Sarah Chen",
    "url": "https://example.com/authors/sarah-chen",
    "sameAs": [
      "https://twitter.com/sarahchenSEO",
      "https://linkedin.com/in/sarahchenSEO"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "SearchInsight",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png",
      "width": 512,
      "height": 512
    },
    "url": "https://example.com"
  },
  "datePublished": "2025-03-15T09:00:00+00:00",
  "dateModified": "2025-11-22T14:30:00+00:00",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/guides/schema-markup-ai-search"
  },
  "keywords": ["schema markup", "AI search", "structured data", "GEO", "generative engine optimisation"],
  "wordCount": 3200,
  "inLanguage": "en-GB",
  "articleSection": "SEO Guides"
}
</script>

Critical fields - do not omit these:

headline - keep it under 110 characters; this is what models will use as the article title when citing
author with sameAs links - the sameAs array of social profiles anchors the author as a real entity
datePublished and dateModified in ISO 8601 format with timezone
publisher with a logo - establishes the publication as an entity

Optional but valuable:

wordCount - signals substantive content
articleSection - situates the content topically
keywords - do not keyword-stuff; list the genuine topics covered

Implementing FAQPage Schema

FAQPage is arguably the highest ROI schema type for AI citation because it structures your content in exactly the format AI models use to answer questions. Each Question/Answer pair is a self-contained, citable unit.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is schema markup?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup is structured data added to a web page's HTML that helps search engines and AI models understand the content and context of the page. It uses vocabulary from schema.org and is most commonly implemented using JSON-LD."
      }
    },
    {
      "@type": "Question",
      "name": "Does schema markup directly affect AI citation?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup does not guarantee AI citation, but it significantly reduces ambiguity about what your content is and who produced it - two of the key signals AI models use when deciding which sources to cite. FAQPage schema in particular structures content in a format that is directly useful for AI-generated answers."
      }
    },
    {
      "@type": "Question",
      "name": "How many FAQ items should I include in my schema?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Include between 3 and 10 question-answer pairs per page. Each answer should be substantive - aim for at least two complete sentences. Avoid ultra-short answers; they signal low-quality content. Prioritise questions that match how users actually search, not just questions that are convenient to answer."
      }
    }
  ]
}
</script>

Implementation guidance:

The name field of each Question should match the actual question as a user would ask it - not a keyword-stuffed variant
The text field of each Answer should be self-contained; assume the model may extract it without the surrounding page context
Do not duplicate your FAQ schema on multiple pages with the same questions - this dilutes the signal and may be treated as duplicate content
Keep answers factually accurate and current; outdated answers cited by AI models create brand risk

Implementing Organisation Schema

Organisation schema is the entity foundation for everything else. Without a strong Organisation declaration on your homepage (or in a sitewide script), your other schema blocks are floating - the publisher and author references have no anchor.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "SearchInsight",
  "legalName": "SearchInsight Ltd",
  "url": "https://searchinsight.io",
  "logo": {
    "@type": "ImageObject",
    "url": "https://searchinsight.io/logo-512.png",
    "width": 512,
    "height": 512
  },
  "description": "SearchInsight provides AI visibility and generative engine optimisation tools for SEO professionals and digital marketers.",
  "foundingDate": "2023",
  "numberOfEmployees": {
    "@type": "QuantitativeValue",
    "value": 28
  },
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "14 Clerkenwell Road",
    "addressLocality": "London",
    "postalCode": "EC1M 5RF",
    "addressCountry": "GB"
  },
  "contactPoint": {
    "@type": "ContactPoint",
    "contactType": "customer support",
    "email": "[email protected]",
    "availableLanguage": "English"
  },
  "sameAs": [
    "https://twitter.com/searchinsight",
    "https://linkedin.com/company/searchinsight",
    "https://github.com/searchinsight",
    "https://www.crunchbase.com/organization/searchinsight"
  ]
}
</script>

The sameAs array is particularly important for AI models - it creates a web of entity references that models can use to verify that your organisation is consistently represented across the web. Include your LinkedIn, Twitter/X, GitHub (if relevant), Crunchbase, and any other authoritative profiles.

The dateModified Signal: Why Freshness Matters

AI models - particularly those with knowledge cutoffs or retrieval systems - weight freshness heavily when deciding what to cite. A page that was published three years ago but updated last month is treated very differently from a page that was published three years ago and never touched.

The dateModified field is your mechanism for communicating recency. But it only works if it is accurate. There is a widespread and damaging practice of updating dateModified without making any substantive content changes - typically to game freshness signals in traditional search. This is counterproductive for AI search and increasingly counterproductive for traditional search too.

What actually works:

Update dateModified only when you make meaningful content changes - new statistics, added sections, revised recommendations, updated examples
When you update, update substantively - AI systems can often detect when the structured data claims freshness that the content does not support
For content that needs to stay current (annual guides, pricing pages, benchmark comparisons), build a content calendar around regular substantive updates and reflect those in your schema
Consider adding a visible "Last updated: [date]" annotation on the page itself - this reinforces the structured data signal with a human-readable one

For AI search purposes, the ideal update cadence for key pages is roughly quarterly for evergreen guides and immediately for any page where a fact has changed. Stale facts on cited pages are how brands get embarrassed by AI answers.

Validating Your Schema Markup

You cannot trust your schema implementation without validation. Use these tools in sequence:

1. Google's Rich Results Test

URL: https://search.google.com/test/rich-results

Tests whether your markup is eligible for Google rich results and catches syntax errors. Not AI-specific, but catches the most common implementation mistakes.

2. Schema Markup Validator

URL: https://validator.schema.org/

The official schema.org validator. More thorough than Google's tool - it checks property types, required fields, and schema.org compliance rather than just Google's subset.

3. Browser DevTools

Open your page, go to Sources, and search for application/ld+json. Read the raw JSON. Is it what you expect? Is it valid JSON? Paste it into https://jsonlint.com/ if in doubt.

4. Screaming Frog or a Custom Crawler

For site-scale validation, use Screaming Frog's structured data extraction or write a script that crawls your sitemap, extracts all JSON-LD blocks, and validates them against schema.org. This is the only way to catch inconsistencies at scale - e.g., pages where the publisher name in Article schema does not match the name in your Organisation schema.

Common validation errors to watch for:

Missing required properties (e.g., Article without headline)
Invalid date formats (use ISO 8601: 2025-11-22T14:30:00+00:00)
Broken image URLs in ImageObject blocks
Mismatched entity names across schema types on the same site
JSON syntax errors (trailing commas, unquoted keys)

Schema for SaaS Products: A Complete Example

Here is a realistic, complete schema block for a fictional SaaS product - designed to maximise AI visibility signals. This would sit on the product's homepage or primary landing page.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://rankradar.io/#organization",
      "name": "RankRadar",
      "url": "https://rankradar.io",
      "logo": {
        "@type": "ImageObject",
        "url": "https://rankradar.io/assets/logo-512.png",
        "width": 512,
        "height": 512
      },
      "description": "RankRadar helps SEO teams monitor how their brand and content appear in AI-generated search results across ChatGPT, Claude, Perplexity, and Gemini.",
      "foundingDate": "2024",
      "sameAs": [
        "https://twitter.com/rankradar",
        "https://linkedin.com/company/rankradar",
        "https://github.com/rankradar-io"
      ]
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://rankradar.io/#product",
      "name": "RankRadar",
      "applicationCategory": "BusinessApplication",
      "applicationSubCategory": "SEO Tool",
      "operatingSystem": "Web",
      "url": "https://rankradar.io",
      "description": "RankRadar is an AI visibility monitoring platform that tracks whether your brand appears in AI search answers. Enter a keyword and domain - RankRadar tests it against multiple AI models and returns a visibility scorecard, competitor comparison, and prioritised GEO recommendations.",
      "offers": {
        "@type": "Offer",
        "price": "79",
        "priceCurrency": "USD",
        "priceSpecification": {
          "@type": "UnitPriceSpecification",
          "price": "79",
          "priceCurrency": "USD",
          "unitText": "per month"
        }
      },
      "aggregateRating": {
        "@type": "AggregateRating",
        "ratingValue": "4.8",
        "reviewCount": "127",
        "bestRating": "5",
        "worstRating": "1"
      },
      "featureList": [
        "AI visibility tracking across ChatGPT, Claude, Perplexity, and Gemini",
        "Competitor citation monitoring",
        "Generative engine optimisation (GEO) recommendations",
        "Historical visibility trend tracking",
        "Keyword-level brand mention alerts"
      ],
      "screenshot": {
        "@type": "ImageObject",
        "url": "https://rankradar.io/assets/screenshot-dashboard.png",
        "width": 1440,
        "height": 900
      },
      "author": {
        "@id": "https://rankradar.io/#organization"
      },
      "publisher": {
        "@id": "https://rankradar.io/#organization"
      },
      "datePublished": "2024-02-01",
      "dateModified": "2025-10-15",
      "inLanguage": "en"
    },
    {
      "@type": "WebSite",
      "@id": "https://rankradar.io/#website",
      "url": "https://rankradar.io",
      "name": "RankRadar",
      "publisher": {
        "@id": "https://rankradar.io/#organization"
      },
      "potentialAction": {
        "@type": "SearchAction",
        "target": {
          "@type": "EntryPoint",
          "urlTemplate": "https://rankradar.io/search?q={search_term_string}"
        },
        "query-input": "required name=search_term_string"
      }
    }
  ]
}
</script>

Note the use of @graph to combine multiple schema types in a single block. This is the recommended approach for pages that need to declare both an Organisation and a Product - it allows you to use @id references to link them together without duplication. The @id values are just URIs - the convention of appending #organization and #product to the page URL is widely used and works well.

Common Mistakes That Hurt More Than Help

1. Implementing schema that contradicts your visible content If your page says "last updated 2023" but your dateModified says 2025, you are creating a trust mismatch. AI systems - and Google - can detect this. Your structured data must accurately reflect what is on the page.

2. Marking up content that does not exist on the page Every property in your schema should correspond to actual content on the page. If you include an aggregateRating in your Product schema but there are no reviews visible on the page, that is spam - and Google will eventually penalise it.

3. Stuffing keywords into schema fields The keywords array in Article schema is not a place to stuff every keyword you want to rank for. Use it to accurately describe the content. AI models can recognise keyword stuffing in structured data just as they can in prose.

4. Using generic author names "author": {"@type": "Person", "name": "Admin"} is worse than no author at all. It signals that you do not have a real author - which is a trust signal against citation. Use real names, with profile URLs and sameAs links wherever possible.

5. Deploying schema once and forgetting it Schema markup rots. URLs break, prices change, people leave organisations, review counts go stale. Build a quarterly schema audit into your SEO workflow.

6. Implementing every possible schema type indiscriminately Adding schema types that do not accurately describe your page's content is not better than adding nothing - it creates noise and can undermine the credibility of your other schema. Be accurate, not comprehensive.

7. Putting the same FAQ schema on every page of your site Duplicate FAQ blocks across many pages dilute the signal and may be treated as thin or duplicate content. Each page's FAQ schema should be unique to that page.

Prioritising: What to Implement First

If you are starting from scratch or doing a structured data audit, here is the sequence that delivers the best return on investment:

Phase 1 - Entity foundation (do this first, on every site)

Organization schema on your homepage - this is the entity anchor for everything else
WebSite schema on your homepage - establishes the domain-brand relationship

Phase 2 - Content provenance (for any site with articles, guides, or blog posts) 3. Article or BlogPosting on every content page - author, publisher, dates 4. BreadcrumbList on every content page - topical hierarchy signal

Phase 3 - High-value AI signals (for sites targeting AI visibility) 5. FAQPage on your most important informational pages 6. HowTo on instructional content

Phase 4 - Product and social proof (for SaaS and e-commerce) 7. SoftwareApplication or Product on product/pricing pages 8. AggregateRating on product pages (only if you have genuine reviews)

This sequence prioritises entity establishment over individual page markup - because schema on individual pages is more valuable when the organisation behind them is clearly declared.

Frequently Asked Questions

Does schema markup guarantee that AI models will cite my site? No - and anyone who tells you otherwise is overstating the case. Schema markup reduces ambiguity and improves trust signals, which increases the probability of citation. It is one factor among many, including content quality, domain authority, and topical relevance. Think of it as a multiplier on good content, not a replacement for it.

Should I implement schema markup if my site already ranks well in traditional search? Yes. Traditional search ranking and AI citation are increasingly different things. A page can rank on page one for a keyword and never be cited by an AI model, because citation depends on clarity and trust signals that schema markup directly addresses.

How do I handle schema markup on pages generated dynamically by a CMS? Most modern CMS platforms (WordPress with Yoast or RankMath, Webflow, HubSpot) generate schema markup automatically. The issue is that auto-generated schema is often incomplete - it will generate an Article block without a proper author entity, for example. Audit what your CMS generates, then extend it with custom schema where needed. For headless architectures, inject JSON-LD via your framework's <head> management (e.g., next/head in Next.js, Nuxt's useHead).

Can I have multiple JSON-LD blocks on a single page? Yes - you can have multiple <script type="application/ld+json"> blocks on a single page. However, for types that are related (Organisation + WebSite + Product on a homepage, for example), it is cleaner to combine them in a single @graph block as shown in the SaaS example above. Separate blocks are fine for genuinely independent schema types on the same page (e.g., an Article block and a BreadcrumbList block).

Does schema markup for AI search differ from schema markup for Google? The underlying vocabulary is the same - schema.org is the standard. The difference is in emphasis. For traditional Google search, the priority is rich result eligibility (FAQPage, HowTo, Product, Review). For AI search, the priority is entity clarity and provenance - Organisation, author identity, dates, and the accuracy of factual claims in structured data. In practice, implementing schema well for AI search will also improve your traditional search schema, so there is no conflict.

How quickly do AI models reflect schema changes? For AI models with fixed training cutoffs, schema changes only matter at the next training run - which could be months away. For retrieval-augmented systems (Perplexity, ChatGPT with browsing, Claude with web access), changes can be reflected within days once the page is re-crawled. Focus your schema work on accuracy and completeness rather than trying to time it to any particular model's update cycle.

Is there a schema type specifically for AI assistants? Not yet - schema.org has not published a type specifically designed for AI visibility. The types covered in this guide are the best available approximations. Watch the schema.org GitHub repository for emerging proposals; the vocabulary evolves in response to how the web is actually used.

Table of Contents