First published: 13 June 2026 · Last updated: 13 June 2026
Schema for GEO is one of the most frequently misframed topics in 2026 SEO content. Vendor blog posts oscillate between "schema is the magic bullet for AI citations" and "schema is dead in the AI era". Both are wrong. The accurate framing: schema is a focused, technical layer that helps generative AI engines parse content efficiently, verify claims, and select sources confidently. It does not directly cause citations, but it raises extraction confidence in measurable ways. The 2024 Search/Atlas study and 2026 follow-ups have made the picture clearer: focused schema that matches content earns citation lift; comprehensive schema that pads schema.org types does not.
This article is the technical implementation depth. Our companion AEO schema types tier list covers the AEO-specific subset; this guide drills into the GEO-specific patterns: which engines use which schema, the deployment technical requirements, the entity-disambiguation pattern, and the JSON-LD samples for each priority type. Pairs with our GEO optimization tactics playbook for the broader generative-engine workflow. The decision-maker version of this argument is published as a companion piece on the BMS blog for non-technical stakeholders.
How Generative AI Engines Actually Use Schema
Three mechanisms. Schema does work in GEO, but understanding the mechanism prevents the over-deployment mistakes that waste effort.
Mechanism 1: Entity extraction confidence. When an AI engine reads a page, it extracts entities (people, products, organisations, places, concepts). Without schema, the extraction relies on natural-language parsing alone, which is error-prone. With Organization, Person, and Product schema present, the engine has a machine-confirmed entity definition that matches the prose. This raises confidence in the extracted entity, which raises the probability that the page is selected as a citation source.
Mechanism 2: Claim verification structure. FAQPage and HowTo schema present claims in a structured Q-and-A or step-and-text format. AI engines can verify the structured claim against the prose claim (do they match?) and use that verification as a quality signal. Pages with internally consistent schema-and-prose earn higher citation confidence.
Mechanism 3: Authority signal mirroring. Article schema with author (linked to a Person entity with sameAs) and dateModified gives the AI engine machine-readable authority signals. The engine cross-references the author entity with external sources (LinkedIn, Wikidata) to assess expertise. Without schema, the engine has to infer authority from prose only, which is less reliable.
The combined effect. Schema does not "rank" your page in any AI engine. It improves the engine's confidence that what it extracted from your page is correct, which increases the probability that your page is selected when the engine has multiple candidate sources. The lift is real but the mechanism is downstream of content, not a substitute for it.
The Engine-by-Engine Schema Reality
Each major generative AI engine uses schema differently. Understanding the differences shapes deployment priorities.
Google AI Overviews and Gemini
Both run on Google's index and parse schema.org markup comprehensively. Confirmed parsing for FAQPage, HowTo, Article, Product, Review, Organization, and most major types. The strongest observed correlations are with FAQPage (highest), Article (with author + dateModified), and Organization (for entity disambiguation).
Deployment priority: full schema stack (FAQPage where applicable + Article + Organization + BreadcrumbList) on every content page.
Bing Copilot
Runs on Bing's index. Bing has historically been more enthusiastic about schema than Google (more rich result types, faster acceptance of new schema.org additions). Confirmed parsing for the same major types as Google plus some Bing-specific additions. Deployment is functionally identical to Google AI Overviews.
Deployment priority: same as Google. The schema stack works for both.
ChatGPT Search (OpenAI)
ChatGPT Search uses a combination of Bing's index (for retrieval) and OpenAI's own crawler (OAI-SearchBot). Schema parsing is partial: FAQPage and Article are observed in citation patterns, Organization is observed for brand-level citations, but the deeper schema types (Product, Review, HowTo) appear less often in cited content.
The implication. ChatGPT Search rewards the same focused schema subset as Google but does not produce additional lift from Tier B types. The 80/20 of GEO schema for ChatGPT is FAQPage + Article + Organization.
Perplexity
Perplexity uses its own crawler and indexed web content. Schema parsing is documented at the entity level (Organization, Person, Product) but the engine relies more heavily on natural-language processing of prose than on structured data. Article schema with author and dateModified appears to influence citation but the correlation is moderate.
Deployment priority: same focused subset (FAQPage + Article + Organization), with extra emphasis on author entity disambiguation via Person sameAs links.
Claude (Anthropic web search)
Claude's web search functionality uses the Brave Search API and Anthropic-developed extraction. Schema usage is undocumented and the observed correlation between schema and citation is weak. Pages with schema do not appear to be cited at notably higher rates than unmarked pages.
Deployment priority: do not deploy schema specifically for Claude. The schema you deploy for Google and ChatGPT is sufficient; no Claude-specific tactics are needed.
The Technical Deployment Requirements
Schema only works if it deploys correctly. The technical baseline.
Requirement 1: JSON-LD in the initial HTML
The schema must be present in the HTML returned by the server (or pre-rendered for static sites), not injected after JavaScript execution. AI engines typically do not execute JavaScript during their initial extraction pass. Client-side-rendered schema is invisible to most generative engines.
The fix patterns:
- Static sites (SSG, Jamstack): schema is baked into the HTML at build time. Always works.
- Server-rendered (SSR) frameworks (Next.js, Nuxt, Remix): schema is rendered server-side and present in initial HTML. Works.
- Client-side rendered SPAs (React, Vue without SSR): schema injected via React Helmet or similar may or may not be visible, depending on whether the AI engine renders. Move to SSR or pre-render the schema specifically.
- WordPress, Shopify, Webflow: schema is server-rendered by the platform or theme. Works by default.
Requirement 2: Schema validates clean
Use Schema Markup Validator (validator.schema.org) for schema.org compliance and Google Rich Results Test for Google-specific interpretation. Both must pass with no errors. Warnings are tolerable; errors are not.
The common errors that block deployment:
- Required properties missing (e.g., Article without author or datePublished)
- Invalid value types (e.g., string where Date expected)
- Malformed JSON-LD (missing braces, trailing commas)
- Multiple conflicting types on the same entity
Requirement 3: Schema matches visible content
This is the discipline most teams fail. Schema must reflect what is actually on the page. FAQs in schema must match FAQs visible to users. Ratings in schema must reflect actual displayed ratings. Author in schema must match the displayed author.
Schema-vs-content drift (FAQs updated on page but not in schema; ratings displayed differently) is the most common silent failure. Quarterly manual audits catch this; automated validation does not.
Requirement 4: Entity sameAs disambiguation
Person and Organization schema include sameAs arrays that link to authoritative external sources. This is the entity-disambiguation signal that AI engines use to confirm "the entity in your schema is the same entity referenced on LinkedIn, X, Wikidata".
Priority sameAs targets:
- Wikidata (highest signal weight; if your entity has a Wikidata page, link it)
- Wikipedia (high signal weight; if entity is notable enough)
- LinkedIn (universal for Person entities)
- X / Twitter (universal where active)
- Crunchbase (for Organization entities, especially startups)
- Industry-specific authorities (e.g., Singapore ACRA for SG companies)
The mechanism. AI engines maintain entity graphs that link mentions across sources. sameAs arrays let your schema participate in those graphs explicitly, raising confidence that you are the entity being discussed.
JSON-LD Samples for the Priority Types
The deployment-ready code samples for the priority GEO schema types. Adjust IDs and values to your domain.
Article + Person (author entity)
```json
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "GEO Schema: Structured Data for the Generative Era",
"datePublished": "2026-06-13T09:00:00+08:00",
"dateModified": "2026-06-13T09:00:00+08:00",
"author": {
"@type": "Person",
"@id": "https://www.bestseo.sg/about/jim-ng/#person",
"name": "Jim Ng",
"url": "https://www.bestseo.sg/about/jim-ng/",
"sameAs": [
"https://sg.linkedin.com/in/jim-ng",
"https://twitter.com/jimng"
],
"jobTitle": "Founder, BestSEO",
"worksFor": {
"@type": "Organization",
"@id": "https://www.bestseo.sg/#organization"
}
},
"publisher": {
"@type": "Organization",
"@id": "https://www.bestseo.sg/#organization"
},
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://www.bestseo.sg/blog/geo-schema-generative-era/"
},
"image": "https://www.bestseo.sg/images/blog/geo-schema.jpg"
}
```
The Person entity uses an @id that other schema blocks (Organization worksFor) can reference. This builds a connected entity graph on your page rather than isolated mentions. AI engines parse the connected graph as a more trustworthy signal than disconnected mentions.
Organization (deployed once site-wide on homepage)
```json
{
"@context": "https://schema.org",
"@type": "Organization",
"@id": "https://www.bestseo.sg/#organization",
"name": "BestSEO",
"alternateName": "Best SEO Singapore",
"url": "https://www.bestseo.sg",
"logo": "https://www.bestseo.sg/logo.png",
"description": "Singapore SEO consultancy specialising in technical SEO, AEO, and GEO for B2B and ecommerce brands.",
"foundingDate": "2010",
"sameAs": [
"https://www.linkedin.com/company/bestseo-sg/",
"https://twitter.com/bestseo_sg",
"https://www.facebook.com/bestseo.sg/",
"https://www.crunchbase.com/organization/bestseo"
],
"address": {
"@type": "PostalAddress",
"addressCountry": "SG"
},
"areaServed": {
"@type": "Country",
"name": "Singapore"
}
}
```
The @id is critical because it lets every other page on the site reference this Organization without re-declaring the full block. This is the single Organization entity for the site.
FAQPage (per-article where 4+ FAQs exist)
```json
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "Does schema markup directly cause AI citations?",
"acceptedAnswer": {
"@type": "Answer",
"text": "No. Schema does not directly cause citations. It raises extraction confidence by 2 to 3x by giving AI engines machine-readable claim structures and entity disambiguation, which increases the probability that your page is selected as a citation source."
}
},
{
"@type": "Question",
"name": "Which generative AI engines use schema markup?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Google AI Overviews, Bing Copilot, and Gemini use schema comprehensively. ChatGPT Search and Perplexity use a focused subset (FAQPage, Article, Organization). Claude's web search shows weak observed correlation with schema."
}
}
]
}
```
The discipline. Each Question name is a complete question. Each Answer text is a 60 to 200 word standalone answer. The schema FAQs match the visible FAQ section on the page exactly.
HowTo (for procedural content)
```json
{
"@context": "https://schema.org",
"@type": "HowTo",
"name": "How to deploy GEO schema on a Next.js site",
"totalTime": "PT30M",
"step": [
{
"@type": "HowToStep",
"position": 1,
"name": "Audit current schema",
"text": "Run Schema Markup Validator on your top 10 content URLs. Catalogue what is deployed and what is missing."
},
{
"@type": "HowToStep",
"position": 2,
"name": "Define entity hierarchy",
"text": "Create the Organization entity (homepage) and Person entities (author profile pages) with @id references and sameAs arrays."
},
{
"@type": "HowToStep",
"position": 3,
"name": "Author per-article schema",
"text": "For each content article, deploy Article + FAQPage (where applicable) referencing the entity hierarchy via @id."
},
{
"@type": "HowToStep",
"position": 4,
"name": "Inject via Next.js Script component",
"text": "Use the Script component with strategy='afterInteractive' or pre-render the JSON-LD into the page head per route."
},
{
"@type": "HowToStep",
"position": 5,
"name": "Validate and monitor",
"text": "Test with validator.schema.org and Google Rich Results Test. Add to CI for ongoing validation. Schedule quarterly manual audits."
}
]
}
```
The discipline. Steps must match the visible page structure. Padding HowTo with imaginary steps violates Google's guidelines and is detected reliably in 2026.
The Entity Hierarchy Pattern
The most underused GEO schema technique in 2026: the connected entity hierarchy.
The pattern. Instead of declaring Person and Organization as standalone blocks per page, declare them once with @id, then reference them via @id from every other schema block. This builds a connected entity graph on your domain that AI engines parse as a coherent identity, not as disconnected mentions.
The implementation:
- Homepage: declare Organization with @id ending in "#organization"
- Author profile page (e.g., /about/jim-ng/): declare Person with @id ending in "#person", with worksFor referencing the Organization @id
- Every content page: declare Article with author referencing the Person @id and publisher referencing the Organization @id
The result. AI engines parsing your domain see one Organization, one Person, and N Articles all connected via @id references. This is structurally cleaner than declaring fresh entities per page and produces stronger entity-graph signals.
The diagnostic. Use Google's Rich Results Test on your articles and look for the "Mentions" section. Properly connected entity hierarchies produce richer entity mention parsing than isolated declarations.
A Worked Deployment: GEO Schema on a SaaS Pillar
Concrete worked example. Client: B2B SaaS (HR tech), pillar page on "best HRIS systems for SG SMEs", 3,400 words, 7 FAQs, comparison table, no procedural steps.
The deployment we shipped:
- Article (BlogPosting) with author @id referencing Person, publisher @id referencing Organization, datePublished, dateModified, mainEntityOfPage.
- FAQPage with 7 question-answer pairs matching visible FAQ section exactly.
- BreadcrumbList with three levels (Home > Resources > Pillar).
- Person declared on author profile page with sameAs to LinkedIn and Crunchbase.
- Organization declared on homepage with sameAs to LinkedIn, X, Crunchbase, Wikidata.
What we did not deploy: HowTo (no procedural steps in pillar), Product (it is a comparative review not a product detail), Review (the comparison references third parties, no aggregate rating).
Outcome at 60 days post-deployment:
- Google AI Overviews: 5 detected citations per 100 sampled SERP queries on related KWs (from baseline 1)
- ChatGPT Search: detected presence on 12 of 30 sampled related queries (from baseline 3)
- Perplexity: detected presence on 8 of 30 sampled queries (from baseline 2)
- Citation rate lift across the three engines: roughly 3.1x average versus the 60-day baseline
The entity hierarchy specifically (the @id linking pattern) was the change that produced the largest single observed citation lift. The Organization sameAs Wikidata was the second-largest contributor.
For complementary cross-site reading aimed at decision-makers, see the BMS companion piece what is generative engine optimization.
Common GEO Schema Mistakes
Patterns of failure we see consistently.
Failure 1: Schema injected client-side via JavaScript only. AI engines often do not execute JavaScript on initial extraction. Move to SSR, SSG, or pre-rendered schema in initial HTML.
Failure 2: No entity disambiguation (sameAs missing). Person and Organization without sameAs arrays. AI engines cannot verify the entity. Always include sameAs to authoritative external sources.
Failure 3: Comprehensive schema with many irrelevant types. Deploying 12 schema types per page does not help. Focused schema (3 to 5 types per page max) outperforms comprehensive deployment.
Failure 4: Schema-vs-visible-content drift. FAQs in schema not on page; rating in schema does not match displayed rating. Quarterly manual audit catches this.
Failure 5: No connected entity hierarchy. Declaring Person and Organization as standalone blocks per page misses the entity-graph signal. Use @id linking.
Failure 6: Article schema without author or dateModified. The two highest-impact Article properties. Always include both.
Failure 7: Deploying Product schema on non-product pages. Service pages, category pages, blog posts that mention products. Direct guideline violation.
How to Validate and Monitor
The validation and monitoring stack we run.
- Schema Markup Validator (validator.schema.org): pre-deployment validation. Catches syntactic errors and required-property violations.
- Google Rich Results Test (search.google.com/test/rich-results): Google-specific interpretation. Confirms Google parses the schema as intended.
- GSC Enhancements report: ongoing property-level monitoring. Surfaces errors per type as they occur.
- Lighthouse SEO audit in CI: automated check on every PR. Blocks deploys with broken schema.
- Quarterly manual audit: re-test 10 to 20 representative pages. Catches schema-vs-content drift.
- Entity verification spot-check: search Wikidata, LinkedIn for your declared entities. Confirm your sameAs arrays still resolve correctly.
The most common silent failure is sameAs link drift (a profile URL changes, a social account is renamed). Quarterly entity verification catches this.
Frequently Asked Questions
Does schema markup help citations from ChatGPT and Perplexity specifically?
Partially. ChatGPT Search uses Bing's index and parses FAQPage and Article schema reliably; Organization schema helps with brand-level citations. Perplexity uses entity extraction and Article-with-author signals. Both engines reward focused schema (FAQPage + Article + Organization) but not comprehensive multi-type schema. Deploy the focused subset and you will see lift on both alongside Google AI Overviews.
Should I use JSON-LD, Microdata, or RDFa?
JSON-LD only. Google has explicitly preferred JSON-LD since 2017, all generative AI engines parse JSON-LD reliably, and the maintenance burden is significantly lower than Microdata or RDFa (which interleave markup with HTML). New deployments should be JSON-LD without exception. Legacy Microdata can be left in place but should not be added to.
How does the @id pattern improve citation rates?
The @id pattern creates a connected entity graph on your domain. Without @id, every page declares fresh Organization and Person entities, which AI engines parse as disconnected mentions. With @id, the same Organization and Person are referenced consistently across pages, which AI engines parse as a coherent identity. The result is stronger entity-graph signals and higher confidence in entity-based citations. Our portfolio data shows roughly 30 to 50 percent additional citation lift from @id linking versus standalone declarations.
Do I need a Wikidata page to compete on GEO?
Not strictly required, but it helps. Wikidata is one of the highest-weighted entity-graph sources for AI engines. SG SMEs without Wikidata pages can compensate with comprehensive sameAs arrays (LinkedIn, Crunchbase, X, industry-specific authorities). The signal weight is lower but still meaningful. For brands with notable enough presence, creating a Wikidata page is worth the effort (typically 4 to 8 hours of editor work).
How often should I audit my schema?
Pre-deployment validation on every change (CI gate). Manual quarterly audit on 10 to 20 representative pages to catch schema-vs-content drift and sameAs link drift. Monthly GSC Enhancements report check for property-level errors. The combination catches the vast majority of issues before they affect citation rates.
Will schema deployment affect organic ranking, not just AI citations?
Indirectly. Schema is not a direct ranking factor, but the secondary effects (rich results display, entity disambiguation, freshness signals via dateModified) can support ranking. The ranking lift is small compared to the citation lift, and the citation lift is increasingly important as AI Overviews take SERP real-estate. Treat schema primarily as a GEO/AEO investment and expect modest organic-ranking benefits as a secondary effect.