Schema Markup for AI Search: How LLMs Read Structured Data
"Does structured data help AI Overviews?" gets answered two ways online: a confident yes from people selling "AI SEO" services, and a shrug from people who have actually looked. Neither is very useful. The honest answer starts with what is publicly documented about how these systems actually fetch and use a page, because that part is checkable, and it turns out to matter more than any claim about ranking preference.
None of the companies running ChatGPT search, Perplexity, or Google's AI Overviews have published the internal weighting their models give to AggregateRating versus a sentence that says "4.7 stars." Anyone who tells you they have solved that equation is guessing. What is published, by the same companies, is how their crawlers fetch a page in the first place, and that is a mechanical, testable fact rather than a ranking opinion. Start there, and see the full structured data guide for the wider map of what to ship.
What's actually documented about how AI search reads your page
Every major answer engine publishes a crawler identity, and the documentation for each one is more specific than most site owners assume. OpenAI lists three separate user agents for different jobs: GPTBot fetches pages to train its models, OAI-SearchBot indexes pages that can be cited when ChatGPT search answers a question, and ChatGPT-User fetches a single page live when someone asks ChatGPT to read or summarize a specific URL. Perplexity documents PerplexityBot as the crawler behind its own indexed answers. Google uses the same Googlebot for AI Overviews as for ordinary Search results; Google's own Search Central documentation says there is nothing separate to build for AI Overviews, because eligibility runs through the regular index. Microsoft's Copilot answers in Bing and Edge are grounded in Bing's search index, crawled by bingbot, per Bing's webmaster documentation.
| Crawler | Company | What it's for | Renders JavaScript |
|---|---|---|---|
| GPTBot | OpenAI | Trains OpenAI's models on public web content | No |
| OAI-SearchBot | OpenAI | Indexes pages ChatGPT search can cite | No |
| ChatGPT-User | OpenAI | Live fetch when a user asks ChatGPT to read one URL | No |
| PerplexityBot | Perplexity | Indexes pages Perplexity can cite in answers | No |
| Googlebot | Crawls for both Search and AI Overviews, same index | Yes, second pass |
That last column is the practical takeaway, and it is the one part of this post that is not speculative. Every documented AI crawler above fetches raw HTML over HTTP and does not execute your JavaScript. Googlebot is the exception, and only because it runs a second, delayed rendering pass after the first crawl. If your AggregateRating or SoftwareApplication block is injected client-side by a script, none of the AI crawlers in that table will ever see it. They will see whatever came back on the first response, nothing more.
This is the same failure mode we documented in why star ratings disappear from Google: markup that only exists after a script runs is markup that a first-pass crawler never sees. For classic search, that costs you a rich snippet. For an AI crawler that never gets a second pass at all, it costs you the citation entirely, because the fact was never in the document the crawler stored.
Why structured data still helps, even without proof of preferential ranking
Set aside whether any of these systems rewards structured data over prose. There is a plainer argument for shipping it anyway: a fact in AggregateRating.ratingValue is a lookup, and the same fact in a sentence is an inference. "Users love it" or even "rated highly by customers" gives a language model nothing to extract with confidence. "ratingValue": "4.7" paired with "reviewCount": "89" gives it a typed number with a stated scale. One requires the model to guess at precision it cannot verify; the other hands it the precision directly.
This is not a new argument invented for AI search. It is the argument for structured data generally, going back to when the only "reader" of your markup was Googlebot deciding whether to render a star snippet. What changed is the number of different systems now parsing the same block. A SoftwareApplication node with a clean AggregateRating used to have one audience deciding one thing (does this page earn a rich result). It now has several: Google's classic snippet renderer, Google's AI Overview generation, Bing's Copilot, and whatever passages ChatGPT search or Perplexity decide to retrieve when a user asks "is <product> any good." None of them have published a preference for structured facts over prose. All of them are easier to feed accurately with structured facts than with prose, because that is simply what structured data is for.
Our July 2026 crawl of 985 reachable SaaS and indie-software homepages, published at /research/saas-review-schema-2026, found that 53.9% ship any JSON-LD at all, and only 10.7% of those validate with zero errors and zero warnings. Just 111 sites (11.3%) expose an AggregateRating, the block most directly answering "is this any good" for anything reading the page. Whatever weight any answer engine gives to structured facts, most SaaS sites are not offering any facts to weight in the first place. The gap is not subtle competition for a marginal ranking signal; it is most of the category handing every crawler on that list nothing machine-readable to work with.
What to actually do about it
The advice here is almost identical to ordinary structured-data hygiene, which is the least exciting and most honest conclusion available. Server-render your JSON-LD, because a crawler that does not execute JavaScript only ever sees the first response. Keep AggregateRating tied to reviews that actually exist and that a visitor can verify, because a self-published number with nothing behind it is a trust problem with a model in exactly the same way it is a trust problem with a person reading the page, or with Google's self-serving eligibility rule. And decide deliberately about GPTBot, OAI-SearchBot, and PerplexityBot in your robots.txt, because blocking a crawler you have never heard of is also blocking the one path that lets an answer engine cite you at all, which is a different tradeoff than opting out of model training.
There is no separate "AI schema" vocabulary to adopt, from any of the companies named above. Schema.org is still the only vocabulary any of them read, and the properties that matter are the same ones that have mattered for Google's rich results since before any of these answer engines existed: name, applicationCategory, offers, and aggregateRating on a SoftwareApplication node, laid out in full in our property reference. If you have not generated that block yet, our JSON-LD generator builds and validates it from a short form rather than asking you to hand-write it, and the same generator is what backs the comparison in which JSON-LD generator actually validates.
The uncomfortable part is that none of this is provably an "AI SEO" tactic, because nobody outside OpenAI, Perplexity, and Google can measure what their retrieval systems weight. What is provable is that most SaaS sites are not even in the game: they ship no structured data, or they ship it in a way no crawler on this list ever sees. Fixing that is not a bet on a new discipline. It is finishing the old one.
Frequently asked questions
No. Google's own Search Central documentation states that AI Overviews draw on the same web index and the same crawling and indexing requirements as regular Search results, and there is no separate structured-data format built for them. Standard, valid structured data such as a clean `AggregateRating` and `SoftwareApplication` block is the same target whether the outcome is a classic rich result or an AI Overview citation.
It can, depending on which crawler you block. `GPTBot` is used for training OpenAI's models, while `OAI-SearchBot` is the separate crawler that indexes pages ChatGPT search can cite in a live answer. Blocking `GPTBot` opts you out of training data without necessarily affecting search citations, but blocking `OAI-SearchBot` removes you from the pool of pages ChatGPT search can reference at all. Decide on each user agent individually rather than blocking all bots by default.
`SoftwareApplication` with a nested, valid `aggregateRating` is the single block most directly useful to anything summarizing "is this product any good," because it states a typed rating value, a review count, and a scale in one place. `Organization` and `FAQPage` markup help with identity and common questions, but the rating block is the one carrying the fact most likely to be quoted back to a user.
Not directly. None of the major answer engines publish which source facts fed a given response, so there is no equivalent of the Rich Results Test for AI citations. The closest available check is asking the assistant the relevant question yourself and seeing whether it names your product and cites a plausible number, though that tells you about one query at one moment, not about the underlying retrieval behavior.
No, not the ones documented so far. GPTBot, OAI-SearchBot, ChatGPT-User, and PerplexityBot all fetch the raw HTTP response and do not execute page scripts, which means any structured data injected client-side is invisible to them. Googlebot is the exception: it runs a delayed second pass that does render JavaScript, but that pass has its own queue and its own failure modes, so server-rendered markup remains the reliable choice for every crawler in this comparison.
No company running a major answer engine has published one. Schema.org remains the only vocabulary any of the crawlers above read, and the properties worth prioritizing are the same ones that have driven Google's rich results for years: a well-formed `SoftwareApplication` node with `offers` and `aggregateRating` filled in correctly. Treat any product claiming a separate "AI schema" standard with skepticism until one of these companies documents it themselves.