Most advice on structured data for AI agents starts from a false premise: that there’s a special “AI schema” layer you can bolt on and agents will pick your site. There isn’t one. Google says so plainly, and no AI vendor has published schema.org properties that earn citations. What does exist is narrower and more useful. Agents read your site in several different ways, and structured data matters a lot to one, a little to another and not at all to a third. Know which agent reads what, and you can put your effort where it pays.
“AI Agent” Covers Several Different Readers
Before you touch any markup, separate the things people lump together as AI agents:
- Index-backed answer engines such as Google’s AI Overviews and AI Mode, or Microsoft Copilot. They answer from a search index that was built by a crawler. That crawler parses JSON-LD while it indexes the page.
- Fetch-and-read assistants. A chat assistant fetches your URL during a conversation, turns the HTML into text and reads it. Most vendors don’t document whether that conversion keeps or drops your JSON-LD block, so you can’t count on it either way.
- Browser and computer-use agents act on the rendered page. OpenAI describes its Computer-Using Agent, the model behind Operator, as working from screenshots of the screen and acting through a virtual mouse and keyboard. A screenshot doesn’t include JSON-LD.
- Protocol agents skip your HTML entirely. They read a product feed, call an MCP server or use a commerce API.
The practical rule: structured data feeds the first group directly and the fourth group indirectly. The second sees it sometimes. The third never does.
What Google and Microsoft Have Actually Said
Google’s documentation on AI features and your website is unusually blunt. It says there are “no additional requirements to appear in AI Overviews or AI Mode, nor other special optimizations necessary.” It also says “there’s also no special schema.org structured data that you need to add.” The only structured-data best practice it lists is making sure your markup matches the visible text on the page.
That fits Google’s intro to structured data, which says markup gives “explicit clues about the meaning of a page.” It aids understanding; it doesn’t decide whether you appear. On the Microsoft side, Search Engine Land reported that Bing’s Fabrice Canel said at SMX Munich in March 2025 that schema markup helps Microsoft’s LLMs, including Copilot, understand content. Note that this was a conference remark reported by the press, not a documented ranking factor.
So the evidence supports a modest claim: schema for AI agents helps index-based systems understand which entity, product, price or author a page describes. No one has shown it moves you into an answer by itself, so a promised citation lift from “AI-optimised schema” is a guess.
Product Schema Is Where Markup Earns Its Keep
If you only fix one type, make it product schema on pages that sell something. Commerce is where agents need exact, machine-checkable facts that prose describes badly: price, currency, stock, shipping and returns. Google’s merchant listing documentation sets the baseline:
- Required on Product:
name,imageandoffers. The offer must be a singleOffer, not anAggregateOffer, because the merchant has to be the seller. - Required on Offer: a price greater than zero and an ISO 4217
priceCurrency. - Recommended: a GTIN,
brand,sku,availability,itemCondition,shippingDetailsandhasMerchantReturnPolicy.
Here’s a trimmed, illustrative example. The values are placeholders. It goes inside a script tag of type application/ld+json:
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Example Trail Shoe",
"image": "https://example.com/img/trail-shoe.jpg",
"sku": "TS-01",
"gtin13": "0000000000000",
"brand": { "@type": "Brand", "name": "Example" },
"offers": {
"@type": "Offer",
"price": "89.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"url": "https://example.com/trail-shoe"
}
}One detail most guides miss: Google now recommends a single global shipping and returns policy on your Organization markup. Product-level policies should only override it. Google also sets a precedence order: product-level Merchant Center feed data first, then Content API settings, then Merchant Center or Search Console settings, then product-level markup, then organization-level markup. On-page markup is the fallback, not the main source.
For Shopping Agents, the Feed Matters More Than the Markup
The systems that let an agent check out don’t read your JSON-LD. They read a feed.
OpenAI’s product feed spec for ChatGPT shopping is its own format, delivered as JSONL, CSV or TSV. Nine fields are required: item_id, title, description, url, brand, seller_name, image_url, availability and price. The spec doesn’t mention schema.org at all. It tells merchants to update price when a sale starts or ends and to update availability when an item sells out. Search visibility is on by default. Checkout is off until you enable a separate integration.
On Google’s side, the Merchant Center help page on the Universal Commerce Protocol says Merchant Center “will continue to be the central hub to prepare your product data.” The checkout button appears on eligible listings in AI Mode in Search and in Gemini. It’s limited to select merchants, covers products in the United States, Canada and Australia, and shows only on listings that carry the native_commerce checkout-eligibility attribute.
Agents that buy work from feeds. The page, the markup and the feed must agree. If the JSON-LD says in stock, the feed says sold out and the page shows another price, you’ve given an automated buyer three versions of the truth. Our guide to product feeds for AI shopping agents covers the feed side.
Actions: The Vocabulary Almost Nobody Reads
Schema.org has had a way to describe what can be done on a page for years, not just what the page is. You attach a potentialAction to a thing. Schema.org defines it as “a potential Action, which describes an idealized action in which this thing would play an ‘object’ role.” You then point it at an EntryPoint with a urlTemplate, which is an RFC 6570 URL template. Annotations like query-input say which values the agent must fill in. Types such as SearchAction, BuyAction, OrderAction and ReserveAction exist in the vocabulary.
On paper, this is exactly what an agent needs. In practice, the best-known consumer of these actions has gone away. Google’s sitelinks search box read SearchAction markup, and Google removed that feature starting November 21, 2024. Its announcement said “there’s no need” to remove the markup. Site-name markup, which uses a variation of WebSite, is still supported.
No major AI agent vendor documents reading schema.org actions today. If you already have SearchAction markup, leave it; it’s harmless. Don’t build a project around BuyAction or ReserveAction markup to win agents, because nothing confirmed consumes it.
Where Agent Actions Are Actually Being Defined
The work on “what can be done here” has moved from markup vocabularies to callable interfaces. The closest thing to schema.org actions that a browser agent can actually use is WebMCP. It’s a proposed web standard being incubated in the W3C Web Machine Learning Community Group, and Chrome is running it as an origin trial. Its declarative form adds attributes to an ordinary HTML form, per Chrome’s developer documentation:
<form toolname="checkStock"
tooldescription="Checks stock for a product at a store.">
<input name="sku" toolparamdescription="Product SKU">
</form>The browser exposes that form as a tool, and its fields become the tool’s input schema. When an agent calls the tool, the browser fills the visible form. An optional toolautosubmit attribute lets the agent submit it. Chrome’s documentation says the API is under discussion and subject to change, so experiment rather than depend on it. Our WebMCP guides cover setup.
Notice the design choice: WebMCP adds actions to forms you already have, so a form with clear labels is already halfway to being agent-callable.
Agents That See Pixels Need Clear Pages, Not Markup
For the computer-use agents, the “structured data” that matters is the visible page itself. An agent working from screenshots, or from the page’s DOM and accessibility tree, needs:
- The price, variant, stock status and delivery estimate printed as visible text near the buy button. Not hidden behind a hover or loaded only after an interaction.
- Form fields with real
<label>elements and buttons whose text says what they do (“Add to cart,” not an icon alone). - Selectors for variants such as size or colour that are actual controls, not images with click handlers.
- Shipping and returns terms on a crawlable page that the product page links to.
This lines up with Google’s structured data policy: “Don’t mark up content that is not visible to readers of the page.” Anything you put in JSON-LD should also be on the page, because one class of agent will only ever see the page. SEO Rocket’s audit crawler is backed by Screaming Frog and renders JavaScript, which matters here: if price and stock appear only after client-side scripts run, an agent reading raw HTML misses them.
NLWeb: Where Schema.org Becomes an Agent Endpoint
Microsoft’s open-source NLWeb project is the most concrete link between structured data and agents. Per its GitHub README, NLWeb builds natural-language interfaces on top of schema.org and related formats like RSS, which it calls “a semantic layer for the web”. It returns responses in JSON using schema.org. The README adds that “every NLWeb instance also acts as an MCP server,” so AI clients can query the site directly.
This matters even if you never deploy NLWeb. Clean schema.org markup is the raw material such a layer consumes; consistent Article, Product or Event data is worth exposing, half-filled markup isn’t. Our NLWeb explainer covers setup.
What to Skip
Skip the advice with no confirmed payoff:
- Invented properties or “AI layers.” Fields schema.org doesn’t define mean nothing to any agent you can name.
- Markup for content readers can’t see. It breaks Google’s policy and doesn’t help the agents that read the page.
- Stacking every type on every page. An
FAQPageblock with no visible FAQ is noise. - Bulk-adding
potentialActionin the hope that an agent reads it. No consumer is confirmed, so it isn’t worth a sprint. - Treating llms.txt as a substitute. It’s a different, unofficial file. Google’s AI features page says you don’t need new machine-readable or “AI text” files to appear.
A Priority Order: Do Now, Watch, Ignore
If you want a working plan for structured data for AI agents, run it in this order:
- Do now: validate the core types that match your pages (
Organization,WebSite,Article,Productwith a fullOffer) and fix errors first. Move shipping and returns to organization-level markup or Merchant Center. Make the markup, page and feeds agree on price and stock. - Do now (stores): treat your Merchant Center feed and, if you sell through ChatGPT, OpenAI’s product feed as your main agentic-shopping data.
- Watch: WebMCP’s origin trial, Google’s UCP rollout beyond select merchants, and NLWeb adoption.
- Ignore for now: schema.org action markup added purely for agents, and any proprietary “AI schema” format.
The free schema validator and product schema generator cover the first step. For the rest, SEO Rocket runs a real-crawler audit and tracks AI visibility from the same chat, so you can see whether cleaner data comes with more AI citations instead of assuming it. That measure-first approach is the same playbook proven across 1,000,000+ ranking pages: fix what’s broken, then measure, then expand.
Structured Data for AI Agents: FAQ
Does structured data help you appear in ChatGPT or AI Overviews?
Not directly. Google says no special schema is needed for AI Overviews or AI Mode. Markup helps index-based systems understand your page, and a Bing executive reportedly said at a 2025 conference that it helps Copilot understand content. Neither company treats it as a ticket into answers.
What is the most important schema for AI shopping agents?
Product schema with a complete Offer (price, currency, availability) plus shipping and returns. Then make sure your Merchant Center and OpenAI feeds match it, because checkout agents read feeds first.
Should I add schema.org actions like BuyAction?
Only if it’s nearly free to add. The vocabulary exists, but no major agent vendor documents using it. For callable actions, WebMCP’s form attributes are the live experiment to watch.
Can browser agents read my JSON-LD?
Screenshot-based agents can’t; others vary. Put every important fact in visible text and treat JSON-LD as a supporting layer.
