Advanced schema markup for AI: how to get cited by LLMs

TL;DR: Schema markup helps AI assistants like ChatGPT, Gemini, and Perplexity understand what your brand is, what it offers, and why it's authoritative. Pages with complete structured data covering entity identity, FAQPage, HowTo, and Speakable schemas get extracted and cited more often. The biggest gap on most sites isn't missing schema. It's schema that contradicts your other signals.

Why does schema markup matter for AI citations?

AI assistants don't read your site the way a person does. They pull meaning from what they can parse fast and reliably, and structured data is a direct machine-readable signal. HTML is ambiguous. A product name in your H1 could be a company, a category, or a slogan. Schema removes the guessing.

When a large language model trains on web crawl data, or when a RAG (retrieval-augmented generation) system like Perplexity fetches a live page, structured data gives the extraction layer something to anchor to. A Product schema with a defined name, description, brand, and aggregateRating tells the system more than what's on the page but how the pieces relate. Plain text can't do that.

A 2024 Authoritas study analyzing 10,000 AI Overview citations found that pages appearing in Google AI Overviews were more likely to carry structured data than pages ranking in the same positions that got passed over [1]. The lift wasn't uniform across schema types, which I'll break down below. The direction is clear: structured data helps.

Here's the mechanism, and it matters more than any magic. Schema doesn't trick AI. It lowers the cost of understanding your page. When that cost drops, your content competes on substance instead of on whether the model can decode your layout.

Which schema types actually influence AI visibility?

Not all schema is equal for AI citation. Some types were built for rich results in traditional search and barely touch LLM extraction. Others map almost perfectly to how AI assistants build answers.

Here's the practical breakdown:

| Schema Type | AI Relevance | Primary Benefit | |---|---|---| | FAQPage | Very High | Verbatim Q&A pairs AI can lift directly | | HowTo | High | Step sequences match AI's answer format for procedural queries | | Article / NewsArticle | High | Establishes authorship, date, publisher for credibility | | Organization | High | Entity identity: what the brand is, its URL, sameAs links | | Person | High | Author entity, expertise, credentials | | Product | Medium-High | Descriptions, pricing, reviews for product queries | | Speakable | Medium | Flags passages ideal for voice/AI extraction | | BreadcrumbList | Medium | Context about content hierarchy | | SiteLinksSearchBox | Low | Mostly a Google Search UI feature | | Event | Situational | Only useful for time-sensitive queries |

FAQPage schema is the highest-leverage type for most content marketers. The reason is structural. When you mark up a question and its answer as FAQPage Question and acceptedAnswer, you hand the AI a pre-formatted extraction unit. The question maps to what a user asks. The answer maps to what the AI should say. That's why tools like RankMath's AI schema markup integration push FAQPage as a default.

HowTo schema matters for procedural content. Mark up a HowToStep sequence, and Perplexity and Google AI Overviews have a much easier time presenting your process as the featured method for that query.

Organization schema is underrated for brand-level visibility. It isn't about one page. It's about your entity. Put a sameAs array in your Organization schema pointing to your Wikidata entry, LinkedIn company page, Crunchbase, and social profiles, and you help the AI's entity resolution layer see that all those sources describe the same brand. That turns you into a known entity instead of a string match. Known entities get cited more reliably [2].

How does entity schema help AI assistants recognize your brand?

Entity recognition is how AI decides whether two mentions of a name point to the same thing in the real world. "Apple" the fruit and "Apple" the tech company are different entities. Schema lets you declare which one you are.

The schema that carries the most weight for entity disambiguation is Organization (or LocalBusiness for local brands, Person for individuals). A well-built Organization block should include:

• @type: Organization
• name: your exact legal or commonly known brand name
• url: your canonical homepage
• logo: a direct image URL
• sameAs: an array of authoritative third-party URLs that represent your brand
• description: a factual description, not marketing copy
• foundingDate, numberOfEmployees, legalName where they apply [11]

The sameAs array is where most companies leave money on the table. Every URL in it is a bridge between your site and an authoritative source about you. Google's structured data documentation treats sameAs as a signal for entity reconciliation [3]. Wikidata, Wikipedia, LinkedIn, Crunchbase, and your official social profiles all belong there.

Entity confidence matters for AI because LLMs tend to have a "known entity" threshold, either in training data or in RAG retrieval. Show up consistently across a web of authoritative sources that all point at the same URL, and you clear that threshold. Exist only on your own website, and you're a string, not an entity. Citation rates differ between the two, though precise numbers are hard to pin down. No AI company publishes entity confidence metrics.

See how this fits the broader AI SEO picture, since entity schema sits under most of the other signals LLMs weigh.

Schema types by AI visibility impact

| | | |---|---| | FAQPage | 95 | | HowTo | 85 | | Organization (with sameAs) | 85 | | Article / NewsArticle | 80 | | Person (author entity) | 75 | | Product | 65 | | BreadcrumbList | 55 | | Speakable | 40 |

Source: Google Developers structured data documentation, 2024; Authoritas AI Overviews Study, 2024

What is Speakable schema and does it still matter?

Speakable schema (SpeakableSpecification) is a Google-introduced way to flag which sections of a page are best for text-to-speech. The first use case was Google Assistant reading news summaries aloud. That never scaled the way Google expected, and Speakable is still marked "experimental" in the Schema.org documentation [4].

The underlying idea aged well, though. The schema uses CSS selectors or XPath to point at the passages that matter most, the ones a voice assistant or AI should reach for first. With Perplexity, ChatGPT browsing, and Gemini all pulling passages to build answers, flagging your best ones is defensible.

Here's the catch. There's no confirmed evidence that Speakable directly changes which passages get cited in AI answers. What we do know: semantic coherence (passages that stand alone) and position (passages near the top) correlate with extraction [1]. Speakable can support those signals. It won't replace them.

My honest take. Add Speakable on high-traffic informational pages where you've already made the first two paragraphs answer the question cleanly. Don't treat it as a substitute for writing good, self-contained answer copy. It isn't one.

How should you structure FAQPage schema to maximize AI extraction?

FAQPage schema is the most directly actionable type for AI visibility, and most implementations get it subtly wrong in ways that cost citations.

The mistakes to avoid:

1. Vague questions. "What is your return policy?" is fine for traditional search. For AI extraction, you want questions that match the natural language queries people actually type. Pull from AlsoAsked, Google's "People Also Ask" boxes, or your own Search Console data.

2. Answers written as marketing copy. AI systems strip promotional language or push it down. The text inside acceptedAnswer should be factual, specific, and complete on its own. If the answer only makes sense after reading the rest of the page, it's a weak extraction candidate.

3. FAQPage on content that isn't really FAQ-formatted. Schema.org guidance says FAQPage should be used only "when the page contains a list of questions and answers about a topic" [5]. Slapping it on a product page with one FAQ section at the bottom can trigger a manual action or, at best, get ignored.

4. Nesting FAQPage inside other schemas incorrectly. It should be a top-level schema on the page, or clearly scoped to the section it represents.

A well-structured FAQPage block in JSON-LD looks like this:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How does schema markup help with AI search visibility?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema markup gives AI systems machine-readable signals about what your content means and how its pieces relate. FAQPage schema in particular provides pre-formatted Q&A pairs that AI assistants can extract and cite without additional parsing."
      }
    }
  ]
}

The answer text runs about 50 words and stands on its own. That's deliberate. Aim for 40 to 90 words per answer. Short enough to extract, long enough to carry authority.

What does a technically correct schema implementation look like?

Technical correctness is the floor, not the ceiling. If your JSON-LD has syntax errors, or references properties that don't exist in the Schema.org vocabulary, crawlers either skip it or flag it.

A few rules matter more than most guides admit:

Use JSON-LD, not Microdata. It's Google's preferred format [6], easier to maintain, and it drops into the <head> without touching the visible DOM. Microdata forces you to annotate live HTML elements, which turns into a maintenance headache. RDFa is effectively legacy for most cases.

One @context per script block. Don't stack multiple JSON-LD objects in a single block unless you use the @graph pattern. @graph is the right move for pages with several schema types, because it makes the relationships between entities explicit.

Keep schema consistent with visible content. This is the most common technical violation that causes real problems. If your AggregateRating shows 4.8 stars in schema but 3.9 on the page, that's a mismatch. Google has documented that schema which "doesn't match what's visible" can result in manual actions [6]. For AI systems the risk is different but related: contradicting signals create uncertainty about which data to trust, and uncertain data gets downweighted.

Validate before publishing. Google's Rich Results Test and the Schema.org validator catch syntax errors and unsupported properties. Run every block through both before you deploy [7].

For teams on a CMS with schema automation (how many AI SEO tools handle it), the validation step often gets skipped because the tool is supposed to handle it. It usually does. Spot-check the generated output anyway, especially after CMS updates.

One more thing. Schema injected by client-side JavaScript can fail to index if the crawler doesn't run JS. Server-side render your schema blocks whenever you can.

How do you use schema markup to appear in Google AI Overviews?

Google AI Overviews (formerly Search Generative Experience) pull from a mix: organic ranking signals, structured data, and what Google describes as reliable, authoritative content [8]. Schema feeds the first two.

Start with a sobering number. Ahrefs published data in 2024 showing that 99.5% of AI Overview links come from pages already ranking in the top 10 organic results for that query [9]. Schema is not a bypass for topical authority. You need both.

Among pages that do rank top 10, the ones pulled into AI Overviews tend to share these patterns:

• Clear Article or NewsArticle schema with recent datePublished and dateModified dates
• Author schema with credible sameAs links (LinkedIn, institutional pages)
• FAQPage schema when the content is structured as questions
• Breadcrumb schema that clarifies content hierarchy
• A first paragraph that answers the query directly (not schema, but strongly correlated)

The dateModified signal earns special attention. AI Overviews deprioritize stale content for queries where recency matters. Keep that date current, and actually update the page when you touch it. Changing the date without changing the content breaks Google's guidelines and gives the AI nothing new anyway.

For a closer look at how Google AI search weighs these signals, there's more detail on the ranking factors that split from traditional organic search.

How does schema markup work differently for Perplexity, ChatGPT, and Claude?

The honest answer: Perplexity, ChatGPT (with browsing or in SearchGPT), and Claude run on different retrieval architectures, and none of them publish exactly how they use structured data.

Here's what we can infer from documented behavior and third-party research.

Perplexity crawls live pages with its own spider, PerplexityBot, and uses a RAG architecture that retrieves and synthesizes from several sources at once. It appears to weight structured data in entity recognition, so Organization and sameAs schema likely affect whether Perplexity knows what you are. For passage extraction, it seems to favor pages where the answer sits near the top and reads as clearly structured, which FAQPage and HowTo both encourage. Perplexity has published no specific schema guidance as of mid-2025.

ChatGPT's training data (through its knowledge cutoff) included Common Crawl and other web corpora where structured data was present. Whether schema in training data meaningfully shapes which entities ChatGPT knows well is genuinely unclear. For browsing mode and SearchGPT, OpenAI has said it uses structured data as part of page interpretation, but the specifics aren't public.

Claude, from Anthropic, uses its Constitutional AI training approach and its own crawler, ClaudeBot. Anthropic hasn't published schema guidance. From external observation, Claude seems to favor content that's clear, well-cited, and built for comprehension over content that's schema-heavy but thin.

The practical read: optimize schema for Google AI Overviews (the most documented target) and treat solid structured data as table stakes for the rest. Nobody has good data on exactly which schema properties move ChatGPT or Claude citations, and anyone claiming otherwise is guessing.

For teams tracking this systematically, tools like Spawned's AI visibility audit monitor citation patterns across engines and flag when your schema changes move visibility scores.

What are the most common schema mistakes that hurt AI visibility?

Most schema guides obsess over what to add. The higher-value question for AI visibility is what you're getting wrong.

Contradicting yourself across sources. If your homepage Organization schema calls you a "B2B SaaS company for enterprise HR" and your LinkedIn page (listed in your sameAs) calls you a "people management platform for startups," the entity resolution system sees a conflict. Pick one description. Make it consistent everywhere.

Using schema as decoration. Marking content as Article when the page has no original writing, or as HowTo when there are no real steps, teaches crawlers to distrust your schema. Google warns against schema that isn't relevant to the page [6].

Skipping BreadcrumbList. This one gets dropped because it feels optional. But breadcrumb schema tells AI systems where a page sits in your information architecture. A page about "choosing a running shoe" at /gear/footwear/running-shoes/choosing-guide/ communicates depth of coverage that the URL alone doesn't.

Not using @id to link entities. When your Article schema references an author, and that author has their own Person schema elsewhere, connect them with @id URIs. "author": {"@type": "Person", "@id": "https://yoursite.com/authors/jane-smith"} creates a graph link that systems like Google's Knowledge Graph can follow.

Duplicating schema across plugins and theme. Classic CMS problem. Your theme outputs a generic Organization block. Your SEO plugin outputs another. Your page builder adds a third. Three conflicting Organization blocks on one page create noise. Audit what your stack already emits before you add more.

Leaving programmatic pages bare. Template-driven pages (product listings, location pages, author archives) often carry zero schema because nobody set up the template. These are high-volume pages that together hold a large share of your AI extraction opportunity.

How do you audit your current schema for AI readiness?

An audit has three layers: coverage, correctness, and coherence.

Coverage asks which pages have schema, which types, and which important pages have none. The fastest way to see it is a crawl with Screaming Frog (which extracts structured data by type) or a dedicated schema tool, then map schema type to page template. You're hunting for gaps: high-traffic informational pages without FAQPage or HowTo, product pages missing Product or Offer, a homepage missing Organization.

Correctness asks whether the schema validates without errors. Run 20 to 30 URLs through Google's Rich Results Test. Watch for warnings about missing recommended properties (they won't break anything but do cut effectiveness) and errors about required properties or invalid values.

Coherence asks whether the schema matches the page and your other signals. Most audits skip this layer. Pull your Organization schema, then your Google Business Profile, your LinkedIn About section, your Wikidata entry if you have one, and your Crunchbase listing. Read them side by side. Are the description, founding year, and category consistent? If not, AI entity resolution has a harder time confidently attributing your content to your brand.

For AI search visibility metrics, schema coherence shows up indirectly in brand citation rate. If citations drop after a migration or a plugin update, a schema audit is the first place to look.

The brandrank.ai visibility insights analysis framework scores entity coherence as a core dimension, which mirrors how AI systems actually weight these signals rather than how traditional SEO audits treat structured data.

What is the relationship between schema markup and generative engine optimization?

Generative engine optimization (GEO) is the young discipline of optimizing content for AI-generated answers rather than, or alongside, traditional blue-link rankings. Schema markup sits where GEO meets technical SEO.

A 2023 study from Princeton, Georgia Tech, and the Allen Institute for AI introduced the term GEO and measured which content properties correlated with citation in AI answers. Adding statistics, quotations, and fluent writing improved citation rates by 30 to 40% in their experiments [10]. That's content-level work. Schema is the structural layer beneath it.

Here's the frame. GEO is what you say. Schema is how clearly you declare what you are and what you've said. You need both. A perfectly structured FAQ with trivial answers won't get cited. A brilliant answer buried in a page with no structural signals might still get extracted if the AI can parse it, but you're leaving probability on the table.

Where schema and GEO overlap in practice:

• FAQPage schema amplifies GEO-optimized FAQ content by making the Q&A structure machine-readable
• Article schema with dated authorship supports GEO's emphasis on citing authoritative sources
• Organization schema with sameAs supports GEO's implicit demand that the source be a known, trustworthy entity
• HowTo schema amplifies step-by-step content that AI assistants favor for procedural queries

For a fuller treatment of how GEO fits a broader strategy, generative engine optimization covers the content-side tactics that pair with the technical schema work here.

How should schema evolve as AI search continues to change?

The honest answer: carefully, and based on evidence, not trend-chasing.

Several things are moving at once. Schema.org keeps adding new types faster than major crawlers implement support. Google's AI features have shifted from SGE (experimental) to AI Overviews (mainstream) to whatever comes next. Perplexity, ChatGPT, and other AI-native products index the web independently of Google, which means the old assumption that "optimize for Google and everything follows" is increasingly wrong.

What that means in practice:

Keep your core entity schema stable. Organization, Person, and the sameAs graph aren't trends. They're infrastructure. Every AI system trying to figure out who you are will use these signals for a long time.

Watch the Schema.org pending vocabulary. New types get proposed in the pending namespace before promotion to stable. Types like SeekToAction and SpecialAnnouncement moved from pending to stable once real-world adoption proved their value [4]. Monitoring pending gives you a 6 to 12 month heads-up on what to evaluate.

Track AI citation rate as a metric, more than organic ranking. Rank tracking tells you where you appear in blue-link results. It tells you nothing about whether ChatGPT mentions you when someone asks a relevant question. The two are related but not identical. A page can rank #5 organically and never get cited by AI, or rank #15 and get cited often because its schema and structure match AI extraction patterns better.

For AI-powered search features specifically, the smart bet is to invest in schema infrastructure now, measure citation rates, and adjust schema types as the evidence stacks up about what AI engines actually extract.

Sources

1. Authoritas, 'AI Overviews Study: Structured Data Analysis', 2024
2. Google Developers, 'Introduction to structured data markup in Google Search'
3. Google Developers, 'Structured data general guidelines (sameAs)'
4. Schema.org, 'SpeakableSpecification'
5. Google Developers, 'FAQPage structured data'
6. Google Developers, 'Structured data general guidelines'
7. Google, 'Rich Results Test tool'
8. Google, 'How Google's AI Overviews work' (Google Search Help)
9. Ahrefs Blog, 'AI Overviews Study', 2024
10. Aggarwal et al., 'GEO: Generative Engine Optimization', Princeton/Georgia Tech/Allen Institute for AI, 2023 (arXiv:2311.09735)
11. Schema.org, 'Organization'
12. Google Developers, 'HowTo structured data'