Shopify and Vercel are rebuilding Hydrogen as an open, runtime-agnostic foundation. Hydrogen now dep…
JSON-LD for Agent Commerce: Schema Fields Buyer Agents Parse
AI buyer agents do not read your storefront like a browser. They read it like an API. In 2026, ChatGPT, Perplexity, and Microsoft Copilot decide in milliseconds whether your product appears in an agent answer, based on the JSON-LD fields you ship. Ship only the Schema.org defaults, and you stay invisible. Ship the right extensions, and you win citations and checkouts.
This post walks through the five fields buyer agents prioritize, a production-ready JSON-LD stack, and how to render it in Nuxt 4 or Next.js 15.
What ChatGPT, Perplexity, and Copilot Actually Parse in 2026
AI-driven traffic to e-commerce sites has grown 393 percent year over year. The eMarketer forecast projects that a double-digit share of product searches in 2026 will start inside an agent conversation. The optimization question shifts: away from title tags, toward structured data an agent can parse deterministically in a single crawl.
Buyer agents are pipelines. They fetch a URL, parse the JSON-LD blocks, normalize fields against an internal product ontology, and decide whether the product belongs in the answer. What is not in your structured data block does not exist for the agent.
Shopify acknowledged this in its Winter 26 Edition Agentic Storefronts release, shipping new schema endpoints so merchants can deliver these fields more easily. This is no longer a trend. It is infrastructure.
Schema.org Defaults Are Not Enough: the Five JSON-LD Fields That Win
If your storefront ships only `Product` with `name`, `price`, and `image`, you are stuck in 2018. Here are the five fields that, in our tests with ChatGPT Search, Perplexity Shopping, and Copilot Daily Shop, carry the highest parse priority in 2026.
1. Product with extended identifiers. GTIN, MPN, and SKU are mandatory. Agents use them to disambiguate products across merchants. Without them, you drop out of comparison answers immediately.
2. Offer with precise availability semantics. `availability`, `priceValidUntil`, `inventoryLevel`, and `deliveryLeadTime` let an agent choose between "buyable now" and "show a competitor". `businessFunction` with `Sell` or `LeaseOut` becomes relevant the moment you support rental or subscription.
3. AggregateRating backed by verified reviews. Agents now measurably discount unverified ratings. Ship `Review` with an `author` that resolves to a verified buyer profile, and keep `reviewCount` plausible against sales volume.
4. FAQPage built from real buyer questions. The single most important AEO asset in 2026. Agents quote FAQ answers directly. Three to five concrete `Question`/`Answer` pairs per PDP, phrased the way a customer would ask, earn direct-answer visibility.
5. BreadcrumbList plus a custom `BuyerAgentCapabilities` extension. Breadcrumbs give the agent category context. The custom extension (a vendor-neutral `additionalProperty` set) signals that the storefront supports agent checkout, reservations, pickup slots, or structured returns. Schema.org has not standardized this yet, but the major agents parse `additionalProperty` with `propertyID` keys reliably.
For more on schema strategy, see our tooling for SEO and GEO tuning, which ships these fields out of the box.
Code Walkthrough: a JSON-LD Stack for Agent-Ready Storefronts
Here is a near-production block for a product detail page. Render the JSON-LD string server-side in `<head>`, never client-side. Agents do not execute JavaScript.
{
"@context": "https://schema.org",
"@type": "Product",
"@id": "https://shop.example.com/p/laioutr-sneaker-x1#product",
"name": "Laioutr Sneaker X1",
"sku": "LR-SNK-X1-42-BLK",
"gtin13": "4006381333931",
"mpn": "LR-X1-BLK-42",
"brand": {
"@type": "Brand",
"name": "Laioutr"
},
"image": [
"https://cdn.example.com/x1/front.webp",
"https://cdn.example.com/x1/side.webp"
],
"description": "Lightweight performance sneaker with recycled upper.",
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "1284",
"bestRating": "5"
},
"offers": {
"@type": "Offer",
"url": "https://shop.example.com/p/laioutr-sneaker-x1",
"priceCurrency": "EUR",
"price": "149.00",
"priceValidUntil": "2026-12-31",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition",
"deliveryLeadTime": {
"@type": "QuantitativeValue",
"minValue": 1,
"maxValue": 2,
"unitCode": "DAY"
},
"businessFunction": "https://schema.org/Sell",
"areaServed": "DE"
},
"additionalProperty": [
{
"@type": "PropertyValue",
"propertyID": "buyerAgent:checkoutSupported",
"value": true
},
{
"@type": "PropertyValue",
"propertyID": "buyerAgent:reservationWindow",
"value": "PT30M"
},
{
"@type": "PropertyValue",
"propertyID": "buyerAgent:returnsPolicyUrl",
"value": "https://shop.example.com/returns"
}
]
}Alongside, ship a second block for the FAQ. Agents quote it as a direct-answer source.
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "Does the Sneaker X1 fit true to size?",
"acceptedAnswer": {
"@type": "Answer",
"text": "The X1 fits true to size. For a wider forefoot, go a half size up."
}
},
{
"@type": "Question",
"name": "Can I return the X1 within 30 days?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Yes. 30 days free returns, even after indoor try-on."
}
}
]
}Validate every block against the Schema.org Validator and the Rich Results Test. Both tools are non-negotiable because they surface cross-field conflicts (for example, `priceValidUntil` in the past) immediately. An agent that sees a conflict drops the entire block.
What This Means for Your Engineering Stack
If you build on Nuxt 4 or Next.js 15, three things matter.
First, SSR is mandatory. In Nuxt 4, render JSON-LD via `useHead()` in a server route or via a dedicated `<JsonLd>` component that renders SSR-only. In Next.js 15, use Server Components and emit the JSON-LD string as `<script type="application/ld+json" dangerouslySetInnerHTML>` from the server path. Client hydration must not overwrite the block.
Second, edge caching is your lever. Buyer agents crawl often, sometimes several times per product per hour during a conversation. A cache-capable edge layer (Cloudflare Workers, Vercel Edge) keeps JSON-LD response time under 50 ms. At latency spikes, several agents fall back to the second-best vendor.
Third, single source of truth. JSON-LD cannot be stitched together from three systems. It comes from your product catalog over GraphQL, is normalized in a composable layer, then injected into `<head>`. That is what we built our Agentic Frontend Management Platform for: one schema layer that ships Product, Offer, Rating, FAQ, and custom capabilities consistently across every channel.
If your stack is still monolithic, moving to a Composable Headless Frontend is the pragmatic step so you stop maintaining JSON-LD in every template fork. The full field reference and Nuxt component examples live in the Developer Docs.
For how an entire storefront is designed to be agent-readable, read our Agent Surface Design guide. For broader context, see Agentic Commerce, AI Agents in E-Commerce 2026.
FAQ
Is it enough to ship only `Product` and `Offer`? No. In 2026, the full stack matters: Product, Offer, AggregateRating, FAQPage, and at least three `additionalProperty` capability fields. Shipping only basics loses direct agent comparisons.
Does FAQPage need to render on every PDP, or is a central page enough? Per PDP. Agents quote FAQ answers in context. A central FAQ page helps for generic questions but does not replace the three to five product-specific Q/A pairs.
How do I avoid inconsistencies between the headless frontend and the PIM? A central composable layer normalizes PIM fields before they are emitted as JSON-LD. Validation runs in CI: every PR that touches a product page triggers a schema lint.
Are custom properties like `buyerAgent:checkoutSupported` officially standardized? No, they are vendor-neutral conventions. ChatGPT Search and Perplexity, however, parse `additionalProperty` with `propertyID` keys reliably. Once Schema.org has an official vocabulary, you remap.
How do I measure whether my JSON-LD strategy works? Two signals. First, citation count in ChatGPT Search and Perplexity (manual sampling or tools like Profound, AthenaHQ). Second, the share of referral traffic from AI sources in your web analytics, segmented by user agent.
If you want to go deeper, keep reading on the Insights blog or book a demo of our Agentic FMP. We will walk you through the schema pipeline for your stack live: Book an Agentic FMP demo.