Product Schema for AI Search: What to Add and What to Skip

Most advice on product schema for AI search starts with a promise: add the right JSON-LD and the assistants will find you. Google’s own documentation says otherwise. Its page on AI features states that there is no special schema.org structured data you need to add to appear in AI Overviews or AI Mode, and no new machine-readable files or markup either.

That does not make product schema pointless. It changes what the job is. Schema is not a ticket into AI answers. It is one of several places where your store states the facts about a product, and those places have to agree. This guide covers what to put in product schema, how Google’s Merchant Center uses it, and where schema stops and the feed takes over.

What Product Schema Does (and Does Not Do) for AI Search

Product schema is JSON-LD that sits in the page’s code and describes the product on it: name, image, price, availability and so on. Search engines read it to produce rich results, and Merchant Center reads it for a second purpose we will get to in a moment.

What it does not do is feed AI assistants directly. Google is explicit that generative search needs no extra markup, and it lists keeping structured data in line with the visible text of the page as a general best practice, not a special tactic. The honest summary is that schema is a hygiene layer. It earns its place by being correct, not by being clever.

The place it carries real weight is Shopping. Google describes structured data markup as a machine-readable copy of your product data on your site that can be shared with Merchant Center. That makes your page a second source of truth next to your feed, and Google compares them.

The Fields Worth Getting Right

Google’s merchant listing documentation separates required properties from recommended ones. For a product, the required set is short: a name, an image, and an offer. Inside the offer, you need a price and a three-letter ISO 4217 currency code. Merchant listings also expect a price above zero.

Everything past that is recommended, and a few of the recommended fields are where products actually differ:

• Availability. One value, using schema.org terms such as InStock or OutOfStock. Merchant Center maps these to its own feed values, so an InStock page and an in_stock feed line up.
• Condition. NewCondition, RefurbishedCondition or UsedCondition, one per offer.
• Brand, SKU and MPN. Brand name as a plain string, a SKU without spaces, and the manufacturer’s part number where there is one.
• GTIN. Google asks you to include all applicable global identifiers, use the most specific one that applies, and write it in numerical form rather than as a URL.
• Ratings and reviews. Only if the reviews are real and visible on the page.
• Price validity. If you include a validity date, keep it in the future. Google warns that a listing may not display when the date has passed.

Here is a compact example of what a clean product block looks like:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trailhead Waterproof Hiking Boot, Men's, Brown",
  "image": "https://example.com/images/trailhead-brown.jpg",
  "sku": "TH-BRN-10",
  "brand": { "@type": "Brand", "name": "Trailhead" },
  "gtin13": "0123456789012",
  "offers": {
    "@type": "Offer",
    "price": "129.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition",
    "url": "https://example.com/products/trailhead-brown"
  }
}

The identifier in that example is a placeholder. In your own markup it should be the real code printed on the packaging and registered to the manufacturer.

Why Merchant Center Reads Your Schema Too

This is the part most schema guides skip. Merchant Center has a feature called automatic item updates, which is on by default. It uses the structured data it finds on your product pages to keep price, availability and condition in your Shopping listings current.

Google’s example is plain: if your latest feed upload says a product costs $4 and the page says $3, the listing is updated to $3. That sounds helpful, and often it is. But the same documentation says a product may be disapproved instead of updated when Google detects a mismatch, and updates can stop altogether if the number of mismatches gets too large. It also says the feature may not work well for products whose price or availability changes more than once a day, and that it is not a substitute for keeping your feed itself current.

Two practical consequences follow. First, if your page has no readable price, availability or condition markup, the products can face product-level disapprovals because the extractors cannot determine the values. Second, a theme or plugin that outputs stale schema is not a harmless cosmetic problem. It is a live input into whether your products stay approved.

Google’s guidelines are blunt about the rule behind this: structured data must match the values shown to the customer, and wrong data on a landing page is a violation.

Where Schema Ends and Your Feed Begins

Here is the limit worth being honest about. Schema describes one page. It is a small, fixed vocabulary: price, availability, brand, identifiers, ratings. It has no place for the richer detail that Google’s AI surfaces now read, such as short benefit statements, spec rows or question and answer pairs. Those live in the product feed as conversational attributes, and they never appear in your page markup at all.

So the split looks like this:

• Schema carries the facts a page must state: what it is, what it costs, whether it is in stock, who made it.
• The feed carries everything Shopping and AI surfaces use to match a product to a question: titles, attributes, highlights, specs, Q&A and variants.

Schema tells Google what is on the page. The feed tells Google, and every AI surface behind it, what the product is. When they disagree, the product looks unreliable, and unreliable products are the easiest to skip.

This is also why a store can have flawless JSON-LD and still be thin where it counts. We covered the page side of this in product page SEO: the page is where the click lands, but the record behind it is what most surfaces read first.

A Short Checklist for Schema and Feed Agreement

Run this against your top sellers first, since a mismatch there costs the most.

1. Compare price. The schema price, the visible price and the feed price should be the same number, in the same currency, after the same discounts.
2. Compare availability. An out-of-stock page that still says InStock in markup is the classic cause of disapprovals.
3. Check identifiers. If the feed has a GTIN, the schema should carry the same one. If neither does, the product is missing something Google rewards, and the gap should be fixed at the source, not papered over.
4. Check variants. Make sure each variant’s markup describes that variant, not the parent product.
5. Validate the markup. Use Google’s Rich Results Test on a sample of product pages after every theme or app update.
6. Fix the feed side. Missing attributes in the feed are penalized in more ways than missing schema. We broke those down in how Google punishes missing feed attributes.

A Note on GTINs

Identifiers deserve their own warning, because the pressure to fill every field is strongest here. A GTIN is a registered product code. It cannot be guessed, generated or copied from a similar item. A wrong one is worse than a blank, because it can send the product to the wrong catalog entry or trigger a disapproval.

UCP Radar treats it the same way. It flags products missing a GTIN or MPN and lists them so you can source the real code from the manufacturer or GS1. It does not make one up. If a product genuinely has no GTIN, the supported path is to say so in the feed, not to invent a value in schema.

Conclusion

Product schema is not the lever for AI search that the marketing around it suggests. Google says so directly. What schema does give you is a second, machine-readable statement of your price, stock and identity, and Merchant Center holds you to it.

So treat it as a consistency problem. Get price, availability and identifiers right on the page, get the same values into the feed, and put the richer detail where the AI surfaces actually read it. If you want to see which products have thin or conflicting data before you start, UCP Radar scores every product in your feed and ships the fixes as a supplemental feed that merges onto your primary feed in Merchant Center.