Schema.org for AI

Q: Which schema types matter most for AI?

Organization and Person matter most because they can carry sameAs, the connection that resolves an entity in the knowledge graph used by AI systems. Article gives a page a clear type and authorship. FAQPage and HowTo declare an answer structure that a parser can already see, but they do not make those answers citable, and Google curtailed their rich results in 2023. Prioritize entity markup over answer-structure markup.

Quick facts

What it is: It is the subset of Schema.org types and properties that affects how an AI engine resolves an entity and parses a page.
Is it a ranking or citation signal?: No. It supports feature eligibility, entity resolution, and parsing. Google states that markup enables eligibility for a feature but does not improve ranking or guarantee that the feature will appear.
Where it acts: It acts in the parsing and entity-resolution layer before retrieval, not in the grounding and selection stage where citability and E-E-A-T matter.
Strongest evidence: Index-integrated AI, including Google AI Overviews and Bing Copilot, uses schema through the search index. Live-fetch chatbots such as ChatGPT and Perplexity read JSON-LD as plain page text rather than parsed structured data (searchVIU, 2025).
Most important property: The sameAs property on Organization or Person connects an entity to the knowledge graph. It is the first property to get right.

1. What “Schema.org for AI” means

Schema.org for AI is the subset of the vocabulary that is relevant to AI citations: the types and properties that affect how an AI engine resolves the entity behind a page and parses the page itself.

Definition (GEO Wiki working definition): Schema.org for AI is the subset of structured-data vocabulary whose presence changes how an AI engine disambiguates the entity behind a page and parses the page reliably. It does not determine whether any passage on the page is citable.

2. Why schema is infrastructure, not a citation signal

Structured data is not a ranking factor or a direct path to citation. Google states that “using structured data enables a feature to be present, it does not guarantee that it will be present.” It also says that a structured-data manual action “doesn’t affect how the page ranks” (see General Structured Data Guidelines). Google’s 2025 guidance for AI search makes the same distinction: markup “makes pages eligible for certain search features and rich results,” but it does not improve ranking (Succeeding in AI search). This resembles the distinction in E-E-A-T §1, which explains why E-E-A-T is not a score.

Markup provides three benefits before an engine selects a passage:

What schema enables	What it does not enable
A reliable, unambiguous parse of the page’s facts	A ranking or citation boost
Entity disambiguation through the knowledge graph	A passage becoming citable
Eligibility for structured or rich surfaces where they still exist	A guarantee that the surface will appear

Schema operates in the parsing and entity-resolution layer before retrieval. It does not operate in the grounding and selection stage, where Citability and E-E-A-T affect the process described in Answer Loop §3:

  page ──► [ PARSE + ENTITY LAYER ]      ◄── schema acts here
              │  facts parsed cleanly
              │  entity resolved (sameAs → KG)
              ▼
  retrieval ──► candidate passages
              ▼
  [ GROUNDING / SELECTION GATE ]         ◄── schema does NOT act here
   citability (shape) · E-E-A-T (trust)      passage shape and trust matter here
              ▼
  grounded answer ──► (maybe) citation

Marking up an FAQ does not make its answers citable. As Citability §2 explains, that depends on the structure of the visible passage. Schema only declares a structure that a parser could already extract.

3. Schema types that matter most for AI

The following types matter because of what they assert to an engine and the signals they support. E-E-A-T §4 explains the related trust proxies.

Type	What it tells an AI system	Signal it supports	What can go wrong
`Organization`	Identifies a site or brand as a specific entity	Entity recognition and knowledge-graph presence	Without `sameAs`, the entity remains ambiguous and unresolved.
`Person`	Identifies an author or expert as a specific person	Entity signals and the trust proxies described in E-E-A-T	An anonymous byline provides no resolvable identity.
`Article` / `NewsArticle`	Identifies the page as an article by a named author on a stated date	Page type, authorship, and freshness	The page, author, and date are not stated in machine-readable form.
`WebSite`	Identifies the site and its search action	Connection to the site entity	Page-level signals remain disconnected from a site entity.
`BreadcrumbList`	Identifies the page’s position in the site graph	Site architecture and context	An orphaned page has no structural context.
`FAQPage`	Identifies questions and answers on the page	A declaration of answer structure (see §2 and §6)	The markup is mistaken for citability, which depends on the visible content.
`HowTo`	Identifies an ordered set of steps	A declaration of answer structure	The markup is mistaken for citability, and Google removed its rich result (§6).

Organization and Person offer the most leverage because they carry the property that connects an entity to the layer used by AI systems. FAQPage and HowTo provide less value because they describe a structure the parser can already see, and both carry the limitations discussed in §6.

4. Schema properties that matter most for AI

Most of the value for entity resolution comes from properties rather than types.

Property	What it indicates	Signal it supports	What can go wrong
`sameAs`	States that the entity is the same one represented by the listed URLs, such as Wikipedia, Wikidata, an official site, or social profiles	Entity recognition and knowledge-graph presence	The entity remains ambiguous because it is not connected to the graph.
`mainEntity`	Identifies the primary subject of the page	Topic and entity association	A page with no clear primary subject cannot resolve cleanly.
`about` / `mentions`	Identifies entities discussed or cited in the content	Topical and entity relationships	The page has no machine-readable topic anchors.
`author`	Identifies the `Person` or `Organization` responsible for the content	Authorship and trust proxies	The content is unattributed, so the trust proxy is absent.
`knowsAbout` / `hasOccupation`	States an author’s area of expertise and professional role	Corroboration of expertise	The markup asserts expertise without a resolvable identity.
`speakable`	Identifies sections suitable for text-to-speech	A beta feature limited to US English news content	It is treated as a general-purpose feature even though support is limited (Google, beta).

sameAs is the key link for entity resolution and the first property to implement correctly. It creates an explicit connection between the entity in the markup and the knowledge graph that the model already trusts. This minimal example shows the relationship:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Co",
  "url": "https://example.com",
  "sameAs": [
    "https://en.wikipedia.org/wiki/Example_Co",
    "https://www.wikidata.org/wiki/Q000000",
    "https://www.linkedin.com/company/example-co"
  ]
}

The example is illustrative rather than a complete template. JSON-LD explains the choice among JSON-LD, Microdata, and RDFa, along with placement and escaping. The Schema Implementation playbook provides complete templates and validation steps for each type. Entity Recognition and Knowledge Graph Presence explain how the resulting identity is resolved.

5. How different AI surfaces consume schema

AI engines do not read schema and then rank the page. The way they use markup at answer time differs substantially by surface, much as the underlying trust mechanisms differ across surfaces in E-E-A-T §5.

Surface	How schema is consumed	Evidence strength
Google AI Overviews / AI Mode	Google’s existing index and structured-data systems apply. AI search uses the same eligibility rules and requires no AI-specific markup.	Strongest. Google’s own documentation supports the claim (AI features).
Bing Copilot	Structured data is used through the Bing index.	Strong. Microsoft has confirmed this use.
ChatGPT / Perplexity (live fetch)	The page is fetched and rendered as text. JSON-LD is read as plain text rather than parsed as a graph.	Strong negative evidence. A controlled test supports this finding.
Claude / Gemini (direct fetch)	Likewise, there is no evidence of dedicated JSON-LD parsing at answer time.	Consistent with the evidence above.

The negative result has empirical support. In a controlled December 2025 test, a price appeared only inside JSON-LD on a page. None of the live-fetch chatbots in the five-system test extracted it (searchVIU). A separate observation found that ChatGPT and Perplexity could surface values from invalid, fabricated schema. This behavior indicates that they read the markup as page text rather than as a parsed structure (Search Engine Roundtable, observation).

These models can still receive entity information through their prior knowledge and the knowledge graph, even when they do not parse a page’s JSON-LD during a live fetch. Entity Recognition and Knowledge Graph Presence explain how identities resolve across platforms.

6. What the evidence supports and where it stops

The evidence supports a limited role for schema. E-E-A-T §6 applies the same distinction between what a signal can establish and what it cannot.

What the evidence shows	What it does not establish
Index-integrated AI from Google and Bing uses structured data	It uses schema through the index to determine eligibility. Google states that this does not provide a ranking boost.
Valid markup that matches content reduces extraction ambiguity	It clarifies what is already there; it cannot create trust or make content citable.
Schema coverage does not correlate with AI citation rates	A December 2024 study found no correlation. Treat schema as a technical baseline rather than a direct citation lever (Search Engine Land).
A vendor can withdraw a rich-result surface unilaterally	In 2023, Google restricted FAQ rich results to government and health sites and removed HowTo rich results entirely (Google).

The FAQ and HowTo changes show why rich-result eligibility is not a durable benefit. Google withdrew a surface that markup had previously made available in a single announcement.

The GEO literature also has an important boundary. Aggarwal et al. measured rewrites to content substance and structure, including the addition of citations, statistics, and quotations. The study did not test schema markup as a variable (KDD ‘24, arXiv:2311.09735; paper summary). Its headline GEO results therefore do not support a claim that adding schema produces the same gains. Applying those results to schema would be the kind of unsupported claim described in §7.

As E-E-A-T §6 explains, trust is earned rather than created through annotation. Schema describes existing content; it does not earn trust on its own. It helps engines interpret what is already on the page, but it cannot create trust or citable content that is not there.

7. Schema spam and other anti-patterns

Each pattern imitates a useful signal but fails trust or abuse checks. E-E-A-T §7 describes the corresponding problems with fabricated authority.

Anti-pattern	Why it looks like it works	Why it actually fails
Markup that does not match visible content	It creates the appearance of rich structure.	A Google manual action removes eligibility, and text-reading AI encounters the contradiction directly.
`FAQPage` stuffing for more SERP space	It creates the appearance of broad answer coverage.	Google has restricted the rich result to government and health sites since 2023, leaving little benefit and an accuracy risk.
Fabricated `Organization` / `Person` markup	It creates the appearance of a resolved entity.	It fails `sameAs` and knowledge-graph corroboration, just as false authorship fails in E-E-A-T §7.
Marking up every element	It appears thorough.	It adds noise, validation errors, and mismatch risk without providing an additional benefit.
JSON-LD that contradicts the page text	It appears more complete than the visible page.	Live-fetch AI reads both versions as text and cannot trust either one.

Invalid or content-mismatched schema is worse than having no schema. It can trigger AI anti-abuse mechanisms in the same way that fabricated authority triggers trust filters, a pattern discussed in AI Content Detection. Google states that there are no special markup techniques for AI features. The markup must reflect content that is already visible.

8. What stays the same across SEO and GEO

Valid schema remains part of the shared technical baseline described in SEO vs GEO and complements the trust considerations in E-E-A-T §8.

Valid markup that matches the visible content remains a shared technical baseline for SEO and GEO. It is inexpensive to retain, but it does not differentiate the page. Removing it can reduce both traditional search eligibility and machine parseability.

Schema is consumed by an entity-resolution and parsing layer that contributes to the model’s prior knowledge, rather than by a rich-result renderer.

Surface	How schema is used
Google AI Overviews	The surface is index-based and reuses Google’s existing structured-data systems. Schema affects eligibility rather than ranking.
Live-fetch chatbots	The markup is read as page text. Its value is indirect, through entity presence in prior knowledge and the knowledge graph rather than through the page’s JSON-LD.

For non-text assets, ImageObject and VideoObject can describe provenance and improve trust and readability; Multimodal Signals explains those effects. JSON-LD explains the underlying choice of markup format.

9. How to use schema for GEO

Schema supports the entity layer, but it does not control the grounding stage described in Answer Loop §3. Implement it accurately, then direct most of the remaining effort toward citability and trust.

Your goal	Recommended resource
Implement or fix markup correctly	Schema Implementation
Choose a format and syntax	JSON-LD
Understand why markup feeds entity resolution	Entity Recognition · Knowledge Graph Presence
Audit schema as part of the whole site	Full GEO Audit
Make a passage citable	Citability
Understand schema’s place in the answer process	Answer Loop
Connect schema to the broader method	Generative Engine Optimization

For the term itself and its neighbors, see the GEO glossary.

References

Official (Google):

Google Search Central: General Structured Data Guidelines · Introduction to structured data markup
Google Search Central: Changes to HowTo and FAQ rich results (2023-08-08)
Google Search Central: AI features and your website · Top ways to ensure your content performs well in Google’s AI experiences (2025-05-21)
Google Search Central: Speakable structured data (beta)

Vocabulary:

Schema.org: Organization, Person, sameAs, FAQPage, HowTo, Article, speakable

Independent / industry:

searchVIU: Schema Markup and AI in 2025: What ChatGPT, Claude, Perplexity & Gemini Really See (2025-12-02)
Search Engine Land: How schema markup fits into AI search — without the hype (2026-03-25)
Search Engine Roundtable: ChatGPT & Perplexity Treat Structured Data As Text On A Page [observation] (2026-02-03)

Academic (boundary reference; schema was not a tested variable):

Aggarwal, P., Murahari, V., Rajpurohit, T., Kalyan, A., Narasimhan, K. & Deshpande, A. (2024). GEO: Generative Engine Optimization. KDD ‘24. arXiv:2311.09735 · paper summary

Frequently asked questions

Does Schema.org markup get my content cited by AI?

Not directly. Markup is not a ranking or citation signal. It makes a page easier to parse and clarifies which entity the page represents, helping a model resolve that entity against its knowledge graph. Whether an engine uses a passage in an answer depends on citability, including the passage's structure, and E-E-A-T, including trust in the source. Schema does not determine that selection. It can make an entity resolvable, but not a passage citable.

Do ChatGPT and Perplexity read my JSON-LD?

Not as structured data at answer time. In a controlled 2025 searchVIU test, a price appeared only inside JSON-LD. None of the live-fetch chatbots in the five-system test extracted it. A separate observation found that ChatGPT and Perplexity could surface values from invalid, fabricated schema, which indicates that they read the markup as plain page text rather than as a parsed graph. They can still receive entity information through the model's prior knowledge and the knowledge graph, but not by parsing the page's JSON-LD during the fetch.

Which schema types matter most for AI?

Organization and Person matter most because they can carry sameAs, the connection that resolves an entity in the knowledge graph used by AI systems. Article gives a page a clear type and authorship. FAQPage and HowTo declare an answer structure that a parser can already see, but they do not make those answers citable, and Google curtailed their rich results in 2023. Prioritize entity markup over answer-structure markup.

Is FAQPage or HowTo schema still worth adding?

It offers only marginal value for AI, and little remaining value as a rich-result tactic. In 2023, Google restricted FAQ rich results to authoritative government and health sites and removed HowTo rich results entirely. The markup can still describe page structure accurately, but it cannot make the underlying answers citable. That depends on the visible content. Add it when doing so is inexpensive and accurate, but do not expect it to increase AI citations on its own.

Can schema markup hurt me?

Yes. The main risk is markup that does not match the visible page. Google can issue a structured-data manual action that removes rich-result eligibility, while AI systems that read markup as page text can see the contradiction directly. Fabricated Organization or Person markup fails sameAs and knowledge-graph corroboration in the same way that false authorship fails E-E-A-T. Invalid or content-mismatched schema is worse than having no schema.

Sources