Ecommerce Product Schema for AI Shopping Agents 2026

Complete Product schema markup is the infrastructure that lets AI shopping agents read, compare, and recommend your products without a human in the loop.

AI shopping agents do not browse. They retrieve structured data, evaluate it against a query, and execute a decision. Pages without complete Product markup are functionally invisible to that pipeline. As we covered in our OpenAI Operator e-commerce SEO playbook, agents read schema.org Product markup before parsing any visual layout. In our client work we see this gap consistently: sites with rich content but thin structured data get skipped by the agent layer entirely.

This post covers which Product properties matter for AI extraction, how agent-facing surfaces like Google AI Mode Shopping and Amazon Rufus consume structured data, where merchant feeds fit alongside on-page schema, a working JSON-LD example, and the failure modes that get sites disqualified.

Which schema.org Product Properties AI Systems Actually Read

Schema.org defines Product as any offered product or service. The property list is long, but AI shopping surfaces weight a specific subset heavily. The properties below are verified against the schema.org/Product specification.

The five properties that determine whether an AI agent can process your product at all are:

• name: the product title as displayed on the page. Agents use name as a primary signal for initial relevance scoring.
• offers (type: Offer): the container for price and availability. Without a populated Offer object, the product cannot be evaluated for commercial queries.
• offers.price: the numeric price value. Must be a number, not a string like “$49.99”.
• offers.priceCurrency: the ISO 4217 three-letter currency code (USD, EUR, GBP). Required for Google merchant eligibility.
• offers.availability: must use a canonical schema.org URL enumeration from the ItemAvailability list. The most common values are https://schema.org/InStock, https://schema.org/OutOfStock, https://schema.org/PreOrder, and https://schema.org/BackOrder. Writing “In Stock” as plain text fails validation.

Beyond those five, the properties that most directly improve AI recommendation rate are:

• aggregateRating (type: AggregateRating): ratingValue and reviewCount. AI agents weight social proof heavily when comparing products in the same category. Our work on review schema and AI brand citations shows that product pages with populated aggregateRating are cited more often on comparison queries.
• gtin / gtin13 / gtin8: Global Trade Item Numbers. These are the primary identifiers Google uses to match on-page schema against Merchant Center feed data. Without a GTIN, Google cannot link your organic schema to your Shopping listing.
• mpn: Manufacturer Part Number. Especially important for technical categories where users search by part number.
• brand (type: Brand): the manufacturer or brand name as a nested Brand object, not a plain string.
• image: at least one product image URL. Required for rich result eligibility.

Two newer properties that unlock enhanced merchant listing experiences are shippingDetails (type: OfferShippingDetails) and hasMerchantReturnPolicy (type: MerchantReturnPolicy). These feed return window and shipping cost displays directly into SERP listings. AI agents weight return-friendliness because the user behind the agent has lower tolerance for friction than a browser-based shopper.

How AI Shopping Agents Actually Consume Product Data

The key distinction between traditional search and AI agents is execution intent. A search engine surfaces results. An AI agent retrieves, compares, and executes. That changes the order in which page elements matter.

Agents read the JSON-LD block in the page head first. They extract name, price, availability, identifiers, and aggregateRating before parsing any visible text. A visually polished product page with missing schema is skipped. As we documented in our Amazon Rufus optimization guide, the COSMO algorithm that powers Rufus trusts structured, machine-readable data over unstructured text because it is consistent and parseable at catalog scale. The same logic applies to Google AI Mode Shopping and OpenAI’s shopping agent.

Price clarity is binary for agent systems. If the agent cannot determine the final all-in price in the first crawl pass, the product is deprioritized. This matters in practice: sale prices, bundle pricing, and multi-variant pages all require explicit Offer objects rather than dynamic text that agents cannot parse reliably. We cover the broader agent-readability framework in our ecommerce GEO and product discovery guide.

Reviews need machine-parseable structure, not just display stars. AggregateRating with explicit ratingValue, reviewCount, and bestRating feeds the agent decision tree. Unstructured review text contributes almost nothing. The content chunking and RAG retrieval framework we use in client work applies here: structured, semantically clear data outperforms dense prose in every AI retrieval context.

Merchant Feeds vs On-Page Schema: Two Systems, One Source of Truth

On-page Product schema and Google Merchant Center feeds serve different but complementary roles. Understanding the difference is practical: a mismatch between them can suppress both your Shopping listing and your organic rich result simultaneously.

Google cross-validates on-page schema against Merchant Center feed data. If your JSON-LD shows a price of $89 but your feed shows $79 (or vice versa), Google treats this as a policy violation. Persistent mismatches can suppress your product rich results and lead to Merchant Center product disapprovals. For sites using WooCommerce or Shopify, the risk is highest after promotional price changes: the Merchant Center feed may update on its next scheduled crawl while the on-page schema updates in real time, creating a window of mismatch. We address the detection side of this in our schema markup for AI search guide.

The practical rule: treat on-page schema as your canonical source of truth. Build the Merchant Center feed from the same database fields. Any feed enrichment (promotional overlays, sale prices) should be mirrored in your schema’s priceValidUntil and priceSpecification properties rather than hardcoded as a different price.

Implementation: A Valid Product JSON-LD Example

The following is a valid JSON-LD implementation. Every property name is verified against schema.org/Product and schema.org/Offer. The availability and itemCondition values use canonical schema.org URL enumerations, not plain-text strings.

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Brushed Brass Pendant Light, Adjustable Cord, E26 Base",
  "image": "https://example.com/images/brass-pendant-light.jpg",
  "description": "Hand-finished brushed brass pendant light with adjustable cord length. Compatible with standard E26 bulb sockets.",
  "brand": {
    "@type": "Brand",
    "name": "LuminaryCo"
  },
  "sku": "LUM-BP-2024",
  "gtin13": "5901234123457",
  "mpn": "LUM-BP-2024-BR",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "83",
    "bestRating": "5"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/products/brass-pendant-light",
    "price": "189.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": {
        "@type": "MonetaryAmount",
        "value": "0",
        "currency": "USD"
      },
      "deliveryTime": {
        "@type": "ShippingDeliveryTime",
        "handlingTime": {
          "@type": "QuantitativeValue",
          "minValue": 1,
          "maxValue": 2,
          "unitCode": "d"
        },
        "transitTime": {
          "@type": "QuantitativeValue",
          "minValue": 3,
          "maxValue": 7,
          "unitCode": "d"
        }
      }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30,
      "returnMethod": "https://schema.org/ReturnByMail"
    }
  }
}

Notice the nested structure. brand is a Brand object, not a string. aggregateRating includes bestRating to anchor the scale. availability uses the full schema.org URL, not the text “InStock”. All three are common failure points in WooCommerce and Shopify theme-generated markup. The full comparison of JSON-LD versus Microdata for AI search contexts is covered in our JSON-LD vs Microdata decision framework.

Common Failures That Block AI Agents

Price Mismatch Between Schema and Visible Page

Google requires that schema values match what is visible on the page. A sale ending at midnight that updates the page price but not the cached schema creates an immediate mismatch. This is the most common cause of manual actions on ecommerce sites in our GEO audit work. We scan for this pattern in every GEO audit we run. The fix is template-level dynamic schema generation, not hardcoded values.

Stale Availability Status

Out-of-stock items left with availability: InStock in schema are treated by Google as deceptive. The right behavior is to update the schema availability to https://schema.org/OutOfStock and keep the Product block active. Removing schema entirely from out-of-stock pages loses rich result eligibility when the item returns to stock and creates volatility in your Search Console Enhancements report. AI agents also deprioritize products they cannot confirm are purchasable, making stale availability a direct revenue problem.

Missing or Invalid Availability Enumerations

The availability field must use one of schema.org’s predefined URL enumerations. Writing “Available”, “In Stock”, or “Yes” as plain text fails validation and blocks rich result eligibility. This is the most mechanically simple fix but also one of the most common errors we find in theme-generated markup, particularly on older Shopify themes that predate the canonical URL requirement.

Aggregate Rating Applied Without Real Reviews

Google considers it deceptive to apply an aggregateRating to a product that has no actual customer reviews. Sites that bulk-generate schema with placeholder ratings receive manual actions. The aggregateRating object should be generated conditionally, only when the product has a real reviewCount greater than zero. This is standard practice in our marketplace and aggregator AI search optimization work.

Product Schema on Category Pages

Product markup should appear on individual product pages only. Applying it to category or collection pages that list multiple products misleads Google. Category pages should use ItemList or CollectionPage schema. The FAQ vs HowTo vs Article schema guide covers the broader structured data decision tree for page types beyond product pages.

Scaling Product Schema Across Large Catalogs

Manual JSON-LD is feasible for a handful of products. For catalogs with thousands of SKUs, the approach is template-level automation: the JSON-LD block is generated from the same database fields that populate the visible page. This ensures price, availability, and identifier fields stay in sync automatically. Platforms like WooCommerce and Shopify both support conditional schema generation through theme templates or structured data plugins.

After deployment, monitor the Enhancements report in Google Search Console under the Products section. This report shows total valid items, items with warnings, and items with errors across your entire catalog. Spikes in “missing field” errors after bulk product imports are the most common signal of schema gaps in new inventory.

The priority order for enrichment in our client work: first, ensure all five required properties are present universally. Second, add aggregateRating and GTIN identifiers to your top 20% of revenue SKUs. Third, add shippingDetails and hasMerchantReturnPolicy to categories where comparison shopping is highest. The agentic search optimization playbook covers the broader framework for prioritizing structured data work across different AI surfaces.

The underlying principle mirrors what our 153,425-citation study found about content structure: structured, semantically clear data is cited more often than equivalent unstructured content. Structured product data is the ecommerce analog of atomic sentences. Each property is a discrete, machine-verifiable fact. Agents trust facts they can verify. That is the practical case for complete Product schema: rich results eligibility and readability by the agent layer that will represent a growing share of your product traffic in 2026.