AI-first SEO that ranks you on Google and inside ChatGPT, Gemini, Claude and Perplexity. Good SEO is GEO
E-Commerce SEO

Merchant Structured Data for Agentic Commerce: Make Products Agent-Ready

A Aashirvad Kumar Oct 5, 2026 9 min read
Merchant Structured Data for Agentic Commerce: Make Products Agent-Ready
Share: f X in W

A new kind of buyer is arriving at your store, and it does not have eyes. When a shopper asks ChatGPT to buy a pair of trail shoes, or tells Google's AI Mode to reorder printer ink, an agent does the browsing, comparing, and checking out on their behalf. ChatGPT's Instant Checkout runs on the Agentic Commerce Protocol that OpenAI and Stripe released as an open standard, and Google has built agentic shopping and delegated checkout into AI Mode. In each case the agent never sees your homepage, your hero image, or your carefully written product copy. It reads structured data.

That shift rewires what a product page has to do. For two decades the job was to persuade a human. Now the same page also has to be legible to a machine that decides, in milliseconds, whether your product is complete enough to recommend and transact. Clean, complete data gets surfaced and bought; vague attributes, missing identifiers, or stale prices get quietly skipped for a competitor whose feed is tidy. This post covers the exact structured data that makes a product transactable, a compact JSON-LD example you can adapt, and the common mistakes that get products dropped.

Key Takeaways

  • Agents read machine-readable data before any human sees your page, so incomplete data means invisible products, no matter how good the page looks.
  • The transactable core is a Product plus a complete Offer: price, priceCurrency, availability, and itemCondition, backed by shipping and return details.
  • Strong identifiers (GTIN, MPN, SKU) let an agent match, compare, and trust your listing against the same product elsewhere on the web.
  • The Agentic Commerce Protocol expects a clean product feed with required fields and live inventory before a product is even checkout-eligible.
  • AggregateRating and Review supply the social proof agents weigh when choosing between two near-identical products.

Why Agents Read Data, Not Web Pages

A human shopper forgives a lot. They infer that a product is in stock because the button is green, guess shipping from a banner, and trust a brand from its logo. An agent infers nothing. It needs each fact stated explicitly, in the places it is built to read: your on-page JSON-LD and the product feed you submit to a platform. When those facts are present and consistent, the agent can compare your product, quote a price, and buy it. When a field is missing or contradicts another source, the safe move is to leave your product out. The winners in agentic commerce are not the prettiest pages, they are the most completely described products.

The Structured Data That Makes a Product Transactable

Everything starts with the schema.org Product type and a nested Offer, which is where transactability lives. At minimum an agent needs the core Offer properties defined by schema.org: price and priceCurrency as an unambiguous number and ISO 4217 code, availability using a value like InStock or OutOfStock, and itemCondition such as NewCondition. Add priceValidUntil so the agent knows the quote is current, not a leftover from last season.

The fields that let an agent actually buy are shipping and returns. Google's merchant listing structured data guidelines require price and priceCurrency, recommend availability, and support shippingDetails (rate, destination, delivery time) and hasMerchantReturnPolicy (return window, method, fees). Reading those up front lets the agent present a complete offer, which is the data hygiene our dedicated e-commerce SEO services put in place. To match your item to the same product elsewhere, add identifiers: gtin (8, 12, 13, or 14 digits with a valid check digit), mpn, and your own sku. Finally, aggregateRating and review supply the trust signals an agent uses to break ties. If you are starting from zero, build the schema markup every website needs first, then layer product data on top.

A Compact JSON-LD Product and Offer Example

Here is a minimal but complete example. In production you place this inside a <script type="application/ld+json"> tag on the product page, with real values pulled from your catalog.

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Trailhead Merino Wool Hoodie",
  "image": "https://example.com/img/hoodie-charcoal.jpg",
  "description": "Midweight 100% merino hoodie for cool-weather trail running.",
  "sku": "TH-HOODIE-CH-M",
  "gtin13": "0123456789012",
  "mpn": "TH-2045",
  "brand": { "@type": "Brand", "name": "Trailhead" },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/products/merino-hoodie",
    "priceCurrency": "USD",
    "price": "129.00",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": { "@type": "MonetaryAmount", "value": "0", "currency": "USD" },
      "shippingDestination": { "@type": "DefinedRegion", "addressCountry": "US" }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "applicableCountry": "US",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30,
      "returnFees": "https://schema.org/FreeReturn"
    }
  },
  "aggregateRating": { "@type": "AggregateRating", "ratingValue": "4.7", "reviewCount": "218" }
}

Notice there is no ambiguity: price is a number, the currency is explicit, availability and condition use canonical schema.org URLs, and shipping and returns are spelled out. That is what a machine needs to treat the product as buyable, not merely browsable.

What the Agentic Commerce Protocol Expects From Your Feed

On-page markup makes a product discoverable, but agentic checkout also runs on a structured product feed. The Agentic Commerce Protocol product feed spec requires a small set of fields for every item: a stable item_id, a title, a factual description, a public url, a real brand, a seller_name, an image_url, an availability status, and a price in an amount-plus-currency format like 129.00 USD. Identifiers such as gtin and mpn, plus a group_id and variant options, let the protocol track sizes and colors as one product family.

Checkout adds a further gate. A product becomes transactable only when you set is_eligible_checkout to true and publish a seller_privacy_policy and seller_tos, and even then the spec is explicit that flipping the flag does not finish onboarding, a live checkout integration must be enabled. The recurring theme is freshness: agents prefer live price and inventory over yesterday's snapshot, so a feed that lags real stock levels shows out-of-stock items and misses in-stock ones. Getting chosen here is the same discipline we cover in agentic search for your business: be complete, be current, be consistent everywhere the agent looks.

Common Mistakes That Get Products Skipped

Most dropped products fail on a handful of avoidable errors. Work through this list before blaming the algorithm:

  • Price mismatches. The price in your JSON-LD, feed, and visible page must agree. A gap reads as untrustworthy data and gets the product filtered.
  • Missing or malformed GTINs. An invalid check digit or a made-up number is worse than none, because it breaks the agent's ability to match your item.
  • Vague or empty attributes. Blank color, size, material, or condition fields leave the agent unable to compare your product, so it recommends a rival with a complete profile.
  • Stale availability. Feeds that update once a day cannot keep up with agentic shopping, which favors live inventory. Out-of-date stock status erodes trust fast.
  • No shipping or return data. Without shippingDetails and a return policy, the agent cannot build a full offer and may drop you at comparison.
  • Thin trust signals. Zero reviews or a missing aggregateRating leaves the agent nothing to break a tie when two products are otherwise equal.

Fixing these is the natural extension of good product page SEO that drives sales: the same clarity that converts humans is what makes your data machine-readable.

Agentic commerce does not replace the discipline of clean product data, it rewards it more directly than search ever did. Complete your Product and Offer markup, keep feed identifiers and inventory accurate, and describe shipping, returns, and ratings without gaps, and your catalog becomes something an agent can confidently buy. To audit your markup and feed against these requirements, get your product data audited and we will map every field holding a product back.

Read More

Frequently Asked Questions

What structured data makes a product transactable by an AI agent?

A schema.org Product with a complete Offer is the core: price, priceCurrency, availability, and itemCondition, plus shippingDetails and a return policy. Add identifiers (GTIN, MPN, SKU) and aggregateRating so the agent can match and trust the listing. On-page JSON-LD and a clean product feed together let an agent recommend and buy it.

What is the Agentic Commerce Protocol?

The Agentic Commerce Protocol (ACP) is an open standard co-developed by OpenAI and Stripe that powers ChatGPT's Instant Checkout. It defines how an agent hands a scoped payment token to the merchant, who charges it while remaining the merchant of record. It also specifies the product feed a merchant must supply.

Do I need a GTIN for every product?

If your product has a manufacturer-assigned GTIN, include it, because it is the strongest way for an agent to match your item to the same product across the web. GTINs must be exactly 8, 12, 13, or 14 digits with a valid check digit. For custom or bundled items without one, supply MPN, brand, and your own SKU instead.

Does schema markup guarantee my product appears in ChatGPT or Google AI Mode?

No. Complete, valid structured data is a requirement, not a guarantee. It makes your product eligible and easy to trust, but agents still weigh price, availability, reviews, and consistency across sources. Markup removes the reasons to skip you; relevance and competitiveness decide whether you win the recommendation.

How often should I update price and availability data?

As close to real time as you can manage. Agentic shopping favors live inventory and current pricing, so a once-a-day feed can show sold-out items as available and hide items you just restocked. Sync price and stock changes to your feed and on-page markup promptly to avoid being filtered for stale data.

Want this handled for you? Our eCommerce SEO services can help you scale rankings and revenue across your catalog.

Explore eCommerce SEO services →
#merchant structured data #agentic commerce #agentic commerce protocol #chatgpt instant checkout #product schema #offer schema #json-ld product #gtin mpn #product feed #availability schema #itemcondition #shippingdetails #merchantreturnpolicy #aggregaterating #google merchant listing #ai shopping #ecommerce structured data #transactable product data #agentic checkout #schema markup ecommerce
A

Aashirvad Kumar

Writes about SEO, digital marketing and growth at Optimize For SEO.

Need help ranking #1?

Get a free AI-search visibility audit. We'll show you exactly what to fix to win rankings and citations across Google, ChatGPT and Perplexity.