Structured Data Formats That AI Purchasing Agents Prefer

The purchase decision has already moved past the storefront. B2B buyers now bring a large language model into the research phase before they ever talk to a sales rep, and Gartner expects AI agents to sit inside 90% of B2B buying activity by 2028, carrying an estimated $15 trillion in spend through agent-to-agent exchanges. Retail is close behind: AI-referred traffic to retail sites jumped more than 800% on Black Friday 2025, according to Gartner. Most brands are optimizing for the wrong reader. They're still writing pages for a human eye and a 2015-era crawler, when the thing actually making the shortlist now is a language model that either finds a labeled fact in half a second or skips the product and moves to the next one.

AI agents don't skim a page the way a person does, and they don't crawl it the way an old search bot did either. They scan for structured feeds, schema markup, and labeled data sheets, pulling facts they can compare across a dozen competing products in seconds. A brand that hasn't made its data machine-readable is simply excluded from that comparison. It's absent from it, before the comparison even starts.

How AI agents process a page differently from both humans and traditional crawlers

Agents work in two stages. A crawl-and-indexing stage that looks something like traditional search feeds into a response-generation stage, where the agent goes back and actively fetches structured data to answer the specific question in front of it. Cross-platform testing has found that ChatGPT, Claude, Perplexity, and Gemini all pull schema markup directly when accessing a page. The behavior doesn't belong to one vendor's model. It's shared across every major platform tested.

Natural language is expensive to work with, computationally. An agent reading a paragraph of marketing copy has to tokenize it, parse the grammar, infer what's actually being claimed, then decide how confident it is in that inference. Structured data skips all of that. A sentence like "starting at $49.99, while supplies last" carries the same information as a JSON-LD Offer block with a price field and an availability field, but the agent reading the prose has to guess at intent, while the one reading the labeled block just reads it. Zero ambiguity, no inference required.

Humans bring context to a purchase that agents don't have and never will. A shopper who's seen a brand's ads for years, or who trusts a friend's recommendation, or who recognizes a logo, is working with information no schema markup captures. Agents get none of it, so a reputation built over decades counts for almost nothing if the underlying page can't be parsed, a part brands still underestimate. Loyalty doesn't transfer to a model reading raw HTML.

Absent a clean structured source, an agent falls back to scraping the page, and scraping fails in two specific, predictable ways. It gets things wrong, missing constraints or commerce context a human catches instinctively, and it gets things stale, quoting a price or a stock status that hasn't been true for days. Retail already has data on what this costs even before agents enter the picture: Syndigo found that 44% of online shoppers have walked away from a purchase because product data was incomplete or unclear. A confused human shopper can call customer service or dig around the site for a phone number. An agent has no such fallback. It usually just misrepresents the product, quietly, to a buyer who was ready to spend money.

So the format matters as much as whether structured data exists at all. A page can technically contain schema markup and still get parsed halfway, or not at all, if that markup sits in the wrong container.

Why JSON-LD is the format AI engines consistently prefer over Microdata and RDFa

There are three ways to mark up structured data on a page: Microdata, RDFa, and JSON-LD. Pick wrong and an agent either can't parse the page cleanly or has to fall back to scraping it, with all the failure modes that entails. This isn't a stylistic call buried in a developer's style guide, and treating it as one is the mistake behind half the "why doesn't our product show up in ChatGPT" tickets. It decides how cleanly an agent can pull the data out at all.

JSON-LD lives inside a <script type="application/ld+json"> block in the page's <head>, fully separated from the HTML that renders the visible page. Microdata and RDFa, by contrast, get woven directly into the HTML tags themselves, attribute by attribute, tangling the structured data with the display markup.

That separation buys JSON-LD three things in practice. Agents can read the structured block without rendering the whole page first, there's no risk of a parsing error caused by HTML markup getting in the way of the data, and updates get simpler, since changing a price or an availability flag in the JSON-LD block doesn't touch the layout at all.

Google's own structured data guidance recommends JSON-LD as the preferred format for machine-readable content. And per cross-platform testing, every major engine tested, ChatGPT, Claude, Perplexity, and Gemini, parsed JSON-LD most cleanly among the alternatives.

Skip Microdata and RDFa for anything new. The payoff for JSON-LD shows up in four places. It brings eligibility for rich results, cleaner interpretation by AI crawlers, a better shot at direct citation in an AI-generated answer, and a stronger tie to knowledge graph entities. In 2025, pages carrying schema markup showed up meaningfully more often in AI-generated snippets than pages without it. One industry analysis found that sites with properly implemented structured data were cited in AI responses 3.2 times more often than sites without.

JSON-LD is the container, though, not the content. What actually goes inside that script block, which schema types a brand bothers to fill out, determines what an agent can pull out of it.

Which Schema.org types AI agents look for first, and what each one signals

Schema.org dates back to 2011, when Google, Microsoft, Bing, and Yahoo jointly built a shared vocabulary for structured data. It's a cross-engine standard, not something one company owns, which is part of why it's held up as the default across every AI platform now parsing it.

Agents look for schema types that answer whatever task the user handed them. Priority runs by task-completion, not by which markup makes a search result look prettier, and brands still chasing rich-result cosmetics are optimizing for a decade-old incentive that AI agents never cared about.

Start with identity and trust. Organization schema covers the legal name, logo, address, contact details, and company identifiers, answering who this entity actually is. LocalBusiness extends that for anything tied to a physical location, adding hours, ratings, and booking actions. The sameAs property links an entity to its profiles on LinkedIn, Wikidata, or Crunchbase, letting an agent confirm it's looking at the right company and not one with a similar name. Of everything in the identity layer, sameAs is the single highest-value addition a brand can make to its Organization markup, and it's also the one most commonly skipped, usually because nobody on the content team realizes it's their job.

The product and commerce layer follows. Product schema handles the baseline: title, description, brand, GTIN, MPN, category, image URL, and product URL. Offer schema attaches the price, using an ISO 4217 currency code, along with availability and sale price. Without it, an agent has no way to confirm a product is even in stock or within a buyer's budget. Service schema covers anything that isn't a physical good, describing what the service does, who provides it, and where it's available.

A conversational layer sits alongside that. FAQPage maps specific questions to direct answers, which lines up with how agents actually generate responses. HowTo breaks a process into numbered steps an agent can lift individually, without reading the whole surrounding article. Google removed FAQ rich results from search listings on May 7, 2026, so FAQPage markup no longer earns an expanded snippet in Google's own results. AI systems still parse it regardless. The reason to keep implementing it now is machine comprehension, not the rich result that used to come with it, and that's worth sitting with: a piece of markup can lose its SEO payoff and keep its AI payoff fully intact.

An action layer completes it. The potentialAction property tells an agent what it can actually do on a page: book something, place an order, run a search, start a conversation. In agentic commerce specifically, potentialAction is the clearest signal a brand can send to an action-capable agent, since it's what moves a page from merely descriptive to something an agent can transact against.

Last is the content layer. Article markup and its relatives feed structured content straight to AI crawlers, cutting out the need to parse messy surrounding HTML. Consistency matters across an entire site here: agents build an expectation of how a brand structures its schema, and markup that's inconsistent from page to page, or stale in places, weakens the trust signal the rest of the site is trying to build.

The four data layers an AI agent needs to complete a purchase decision

Schema and feed formats only carry data an agent can trust if the underlying product information is actually complete. A framework from commercetools lays out four layers of AI-ready product data: master, dynamic, outcome-focused, and organizational. Each layer builds on the one beneath it, and a gap low in the stack causes problems at every layer above it. Get master data wrong, and it doesn't matter how good the outcome-focused copy is three layers up. That's the part most content teams get backwards: they polish the top layer first, when it's the foundation that decides whether any of it gets read at all.

Master data is the basic layer: SKUs, dimensions, weight, materials, country of origin, color, compliance certifications. It's the first thing an agent queries, and if it's missing or tagged inconsistently, the agent can't reliably identify the product at all. The common failure here is dumping everything into a free-text description field or a PDF spec sheet instead of tagging each attribute properly. Machines can't act on an unstructured block of text, no matter how thorough it reads to a human.

Dynamic data covers the parts that move: pricing, stock availability, promotions, lead times, return policies. This is the line between an agent that can merely describe a product and one that can actually transact against it, since no agent completes a checkout on data it can't trust to be current. Gartner notes that some AI platforms already run a live check on price and inventory immediately before checkout, which means a static snapshot from a few hours ago isn't good enough anymore. Keeping the product feed refreshed frequently is essential so prices and stock levels stay close to real time.

Outcome-focused data is where a product's specs get translated into the language a person actually uses when asking an AI for a recommendation. Master data might say fabric type and weight. Outcome data says the product is built for wet-weather hiking, packs down small, and uses sustainable materials, a much closer match to what someone actually types into a chat window. Short, plain-language answers embedded in structured fields serve agents fielding exactly that kind of conversational query.

Organizational data sits at the brand level: country of origin, carbon-neutral status, B Corp or Fair Trade certification, ethical sourcing claims. Buyers increasingly tell their AI assistants to filter by criteria like these, and a brand with no organizational data attached simply doesn't show up in that filtered result, regardless of how good the product itself is.

A brand can have flawless JSON-LD on every single page and still lose the sale, if the data feeding that markup is thin. The markup is only ever as honest as what's underneath it.

Feed formats for agentic commerce channels: OpenAI, Google UCP, ACP, and MCP

Schema markup on a page is necessary, but it isn't the whole job. Agentic commerce channels expect a product feed built to their own protocol, separate from whatever's embedded in the page's HTML, and treating the page markup as sufficient is the mistake most merchants make the first time they hear the word "agentic."

Four formats matter right now. OpenAI's commerce feed specification powers product discovery inside ChatGPT Shopping, and it accepts CSV, TSV, XML, or JSON, reaching the broad user base that ChatGPT Shopping serves. Google's Universal Commerce Protocol (UCP) is its own feed standard built for AI-driven product surfaces. Stripe's Agentic Commerce Protocol (ACP) is the integration layer behind in-chat checkout, and Instant Checkout has been live since September 2025. MCP, the Model Context Protocol, enables real-time inventory and pricing lookups and is the most dynamic of the four, built for catalogs that change fast.

ChatGPT's feed has specific minimums. A product title, description, price tagged with an ISO 4217 currency code, availability status, images, and eligibility flags are all required fields. Miss one of these and the listing likely doesn't qualify at all.

There's a real cost attached to this channel, and it belongs in the margin math before anyone commits volume to it. OpenAI charges merchants a transaction fee on completed Instant Checkout purchases, with Shopify beginning to onboard merchants onto the feature in early 2026. Add standard Stripe processing on top, and the combined platform and processing fees on a typical order represent a meaningful margin consideration.es. At scale this is not a rounding error, and any merchant running the numbers on this channel needs to run them before committing volume, not after.

Platform tooling is starting to catch up to what these protocols actually require. Shopware's 6.7.10.0 release, out May 6, 2026, added an experimental agentic commerce sales channel type, and its product exports now support JSONL, the format most modern AI commerce protocols expect, alongside the CSV and XML options already there.

Update frequency matters nearly as much as format choice. A feed that refreshes often enough keeps pricing and inventory signals accurate through a live pre-checkout check, while a feed updated once a day risks failing that check even when every field is technically correct on paper. For any brand running more than a handful of SKUs, this turns into a multiplication problem fast: each feed format carries its own field requirements, and keeping all of them accurate at scale takes systematic data governance, not a one-off export job somebody remembers to run every few weeks.

The 12 baseline attributes and the enrichment layer that separates winning products from visible ones

Twelve attributes make up the baseline for a JSON-LD Product entry, and agentic commerce feeds expect the same set: title, description, brand, GTIN, MPN, category (mapped to Google's Product Taxonomy), price, sale price, availability, condition, image URL, and product URL.

Most retailers already feeding Google Shopping have the bulk of these covered, which breeds a false sense of readiness. AI agents expect the full set, not most of it, and a field left blank functions exactly the same as a field that was never built: the agent treats it as a required signal missing, not a minor gap worth overlooking.

Beyond the baseline sits an enrichment layer, somewhere in the range of 20 to 30 additional attributes, and this is where the real competition happens, between products that look identical on the baseline twelve. Physical specifications, material, dimensions, weight, color, size, need to be formatted numerically with standard units, so an agent can match a product against a constraint a shopper mentioned, like a storage limit or a weight cap for travel. Audience signals cover age group, gender, intended use, occasion. Provenance and trust attributes cover ingredient lists, certifications, sustainability claims. A structured Q&A block, answering the questions an agent is likely to field about the product, rounds out the layer.

Agents lean on these enrichment attributes hardest exactly when two products are otherwise neck and neck, which makes completeness here a genuine competitive edge, not a box-ticking exercise handed off to a compliance team.

Variant-level completeness carries the same weight as the baseline, a detail most catalogs get sloppy about. Every size, color, and spec option needs its own accurate data, current and specific to that variant, because an agent that surfaces the right product but the wrong size produces the same abandoned sale as an agent that never found the product at all. Inconsistent attribute formatting across a catalog, one listing weight in pounds and another in kilograms with no unit label at all, quietly undermines the entire enrichment layer, since an agent comparing across products needs the units to actually match before it can compare anything.