Google said it again this month: you don’t need schema.org markup to appear in AI Overviews or AI Mode. That’s true. It’s also true that pages with rich JSON-LD get cited more often in Perplexity and ChatGPT. This post exists to reconcile those two facts—honestly, without the hype.
The contradiction in one paragraph
Google’s developer documentation is unambiguous. Its guidance on AI features states: “You don’t need to create new machine readable files, AI text files, or markup to appear in these features. There’s also no special schema.org structured data that you need to add.” Now set that next to what practitioners keep publishing. One field analysis of Perplexity’s Sonar found that pages carrying three or more JSON-LD FAQ entries captured citations in 41% of appearance cases, versus 24% for pages without FAQ markup. Both observations are real. The tension between them is the whole reason this article exists—and the resolution is more interesting than either camp’s headline.
Why Google is technically correct—for Google
Start with the mechanism. As of January 2026, Gemini 3 became the default model behind AI Overviews worldwide, with AI Mode running Gemini 3 Flash and Pro. These are models that read full-page HTML and extract intent from prose directly. They don’t need JSON-LD as a pre-processing crutch to understand that a page is about a plumber in Leipzig or a SaaS billing tool.
More importantly, Google built its AI surface on top of its own crawler and its own Knowledge Graph—years of accumulated entity context about who you are and what you sell. For an established site, Google has already resolved your entity. Structured data adds little marginal lift on Google’s surface because Google extracts the same facts from your visible copy and its existing graph. That’s a Google-specific architectural truth, not a universal law of AI. And the distinction matters enormously the moment your goal is to be cited somewhere other than Google.
How Perplexity’s Sonar crawler actually uses structured data
Here’s where a lot of GEO advice gets the mechanism wrong, so let me correct it plainly. Perplexity does not parse your JSON-LD as typed objects at answer time. Its crawler converts pages to Markdown during ingestion, and that conversion strips JSON-LD <script> blocks before the language model ever sees them. A controlled test across five AI systems confirmed the same thing from the other direction: none of them extracted data that existed only inside JSON-LD. Hidden Microdata and RDFa weren’t recognized either. If a fact lives exclusively in your markup and nowhere in visible text, the model can’t see it.
So why does the FAQ correlation show up at all? Because schema’s influence on Perplexity flows indirectly. It strengthens the entity-graph and traditional SEO signals that Sonar’s retrieval layer already trusts. Sonar vector-embeds retrieved pages, chunks them into paragraph-level passages, and scores each passage independently. Declared Q&A blocks tend to line up with clean passage boundaries—which is the most plausible reason the FAQ-marked cohort gets retrieved faster and cited more often (one analysis clocked roughly six hours faster to first citation). The content still has to be visible in HTML. The markup reinforces it; it doesn’t replace it.
One rule survives every version of this story: your schema must describe what’s visibly on the page. Mismatched markup is treated as worse than none—it degrades trust signals across the whole domain. In the audits I run, the most common finding isn’t bad schema; it’s zero schema. A page with the entity name, the service type, and real Q&A content all present in the copy, but nothing typed—so every non-Google engine has to reconstruct your identity from raw text each time it crawls you.
How ChatGPT retrieval handles attribute-rich schema
ChatGPT’s retrieval pipeline leans on Bing-indexed content plus GPTBot’s own crawl. Bing has processed Schema.org types since the vocabulary’s early days, and Microsoft’s Bing Webmaster Guidelines reference structured data as a factor in citation eligibility for Copilot responses. The one on-the-record confirmation from inside a major platform came from Microsoft’s Fabrice Canel, reported at SMX Munich in March 2025 and noted since by several practitioners: schema markup helps Bing’s LLMs understand content for Copilot. Treat that as the single first-party signal it is—useful, but not a controlled result.
The practical upshot for ChatGPT: schema behaves like a retrieval-precision signal, not a ranking lever. Product pages with real price and availability attributes resolve ambiguous queries more cleanly. LocalBusiness contactPoint and hoursAvailable reduce how much the model has to hedge on location-sensitive answers. FAQ Q&A pairs can surface as retrieval candidates somewhat independently of a page’s organic position. None of that guarantees a citation. It narrows the model’s uncertainty about what your page is—which is a different, more durable kind of value.
The five schema types with the clearest AI signal
Five types earn their place. For each, here’s the observed effect, the minimum attributes that matter, and a plain before/after. I’m deliberately not re-teaching the markup syntax here—see our blog for the type-by-type implementation guides.
- Organization — the entity anchor. The
sameAsproperty is the primary disambiguation mechanism across engines: each link is a merge instruction that consolidates your profiles and site into one confirmed entity node. Entity resolution runs before content retrieval, and brands that fail it get excluded before passage scoring even begins. Minimum set:name,legalName,url,sameAs(LinkedIn plus Wikidata—Wikidata feeds Google’s Knowledge Graph directly),contactPoint. Before: three profiles the engines can’t confirm are the same company. After: one node. Observed value in Perplexity and ChatGPT; in the audits I run, most sites haven’t deployed it at all. - Article / BlogPosting — makes editorial content citable as a named source. Minimum:
author,headline,datePublished,dateModified. Before: an undated wall of text. After: a dated, attributed piece a model can cite with a byline and a freshness signal. Useful across engines. - FAQPage — turns Q&A into atomic retrieval units. Minimum:
QuestionplusacceptedAnswer, matching visible copy. Before: answers buried in prose. After: passage-boundary-aligned chunks. Caveat that matters: Google deprecated FAQ rich results in May 2026, so this type has lost its traditional Google return—but the schema.org type stays valid and unused structured data does not harm Search. Its remaining value is for non-Google engines, and even there it’s behaviorally observed, not platform-confirmed. - Product with rich attributes — precision for commerce queries. Minimum:
price,availability,aggregateRating. Before: “this product exists.” After: “this product, at this price, in stock.” Helps ChatGPT resolve ambiguous product questions and can power Perplexity product cards. - LocalBusiness / ProfessionalService — for location-sensitive answers. Minimum:
contactPoint,hoursAvailable,areaServed. Before: a model hedging “check their website for hours.” After: a confident, location-scoped answer. Strongest for ChatGPT location queries and Google’s local AI cards.
The binary: entity vs. text blob
Here’s the mental model I keep coming back to. A page with valid Organization and Article JSON-LD is a typed entity: a known name, type, author, and topic. A page without it is a probability distribution over possible meanings. Every AI engine resolves that distribution differently. Google usually resolves it correctly for established sites, because it has the prior context to do so. Perplexity and ChatGPT often don’t—they’re working from a thinner, borrowed graph.
That’s why “no schema” is not a neutral position for a new or niche B2B service site. It’s an active choice to let each engine guess your entity type independently, with no guarantee they agree. But keep the honesty valve open: the widely repeated stat that AI-cited pages are two-to-three times more likely to carry schema is correlational. Authoritative, well-maintained sites keep schema and attract citations—for reasons that overlap but aren’t the same. Schema is part of the infrastructure reliably-cited sites maintain. It isn’t a shortcut to being one of them.
Decision matrix: which schema types to prioritize for which engine
Impact ratings below reflect observed behavior and mechanism, not controlled causal proof. “Claude web browsing” reads visible HTML and, like the others, ignores facts hidden only in markup—so its column is uniformly low. Ratings: High / Medium / Low / None.
| Schema type | Google AI Overviews | Perplexity | ChatGPT | Claude browsing |
|---|---|---|---|---|
| Organization | Medium — already in Knowledge Graph for known sites | High — sameAs confirms cross-source identity | High — feeds Bing entity metadata | Low — reads visible text |
| Article/BlogPosting | Low — extracted from prose anyway | Medium — author + freshness signals | Medium — attribution + dateModified | Low |
| FAQPage | Low — rich results deprecated May 2026 | Medium — passage-boundary alignment | Medium — retrieval candidates | Low |
| Product (rich attrs) | Medium — merchant/rich results | Medium — product cards | Medium — query precision | Low |
| LocalBusiness | Medium — local AI cards | Low | Medium — location queries | Low |
The rule you can quote back to a client: if your goal is citations outside Google’s own surface, structured data isn’t optional—it’s the entity-registration layer that non-Google engines fall back on precisely because they don’t have Google’s entity graph.
Priority implementation order for B2B and SMB service sites
Ordered by leverage, framed in hours of work rather than technical difficulty—because that’s the language a decision-maker actually budgets in.
- Organization with
legalName,sameAs,contactPoint,areaServed. The anchor every other type builds on. Roughly 1–2 hours once you’ve gathered your profile URLs. Add a Wikidata entry to your sameAs chain if you have one—it’s the highest-impact target. - Article / BlogPosting on every editorial page:
author,datePublished,dateModified,headline. If your CMS templates it, this is a half-day once, then automatic. - FAQPage on every service page that already carries Q&A in the HTML. The content is written; the markup is the only missing step. Budget an hour per page, less if templated.
- LocalBusiness or ProfessionalService—only if geo-targeting is a real conversion factor. A couple of hours.
- Product / Offer—only for pages with genuine pricing data. Skip it if your prices live behind a quote.
A minimal Organization block to paste and adapt as your starting point:
{
“@context”: “https://schema.org”,
“@type”: “Organization”,
“name”: “Acme Advisory”,
“legalName”: “Acme Advisory LLC”,
“url”: “https://acme.example”,
“sameAs”: [
“https://www.linkedin.com/company/acme-advisory”,
“https://www.wikidata.org/wiki/Q00000000”
],
“contactPoint”: {
“@type”: “ContactPoint”,
“contactType”: “sales”,
“email”: “hello@acme.example”,
“areaServed”: “DE”
}
}The citability claim—and what it means for your audit
So here’s the clean version, the one I’d let a client repeat in a meeting: structured data is Google-optional and multi-engine hygiene. No controlled study shows schema alone causes AI citations—but every non-Google engine lacks Google’s entity graph, so JSON-LD becomes the entity-registration layer they lean on. A page with valid Organization, Article, and FAQPage markup is a typed, citable entity. Without it, the same page is an unclassified text blob that each engine re-guesses on its own terms.
That has a direct audit consequence. Any GEO audit that benchmarks citation rate without controlling for schema coverage is measuring two variables at once—content quality and entity-extractability—and can’t tell you which one moved. Structured data is the baseline hygiene layer you check before you measure citation share. It’s also why, if you’re tracking how ChatGPT, Perplexity, Gemini, and Google AI Overviews actually describe you over time, you want a monitor that separates the two. We built Cited to watch exactly that: which engines cite you, how they describe you, and where the description drifts.
Our AI Visibility Audit runs entity-extraction as its own pass/fail dimension before it measures citation share—because a page that can’t be entity-extracted can’t be reliably cited, no matter how good the writing is. Get the hygiene layer right first. Then the content work you do on top of it actually compounds.