# Product schema for AI shopping: getting products into AI answers.

When a shopper asks an AI engine for the best product under a budget, the engine assembles its answer from sources it can read and trust. Product schema is how you hand it the facts it needs (price, availability, rating, identifiers) in a form it cannot misread. Here is exactly what to mark up, the mistakes that get your markup ignored, and how feeds and on-page schema split the work.

## The short answer.

Product schema is structured data that describes a product to machines: name, brand, identifiers, an Offer with price and availability, and ratings or reviews. To get products surfaced and cited in AI shopping answers (ChatGPT shopping, Gemini, Perplexity, and Google AI Overviews with Merchant listings), put complete, accurate Product schema on every product page, keep your product feed in sync with it, and write the visible copy so the engine has real language to quote. The engines lead with price, stock, and trust signals, so those are the fields that decide whether your product gets named or skipped.

## How AI shopping answers actually get built.

An AI shopping answer is not one system. It is two pipelines feeding the same response:

1. **The structured-listing pipeline.** Engines pull from merchant programs and product feeds (Google Merchant Center being the largest) to power price comparisons, product cards, and the "here are five options" grid. This data is feed-driven and identifier-matched.
2. **The organic-citation pipeline.** When the engine reads your actual product page (because it crawled it or fetched it live), it needs the same facts in on-page JSON-LD plus prose it can lift. This is where the citation, the named recommendation with a link back, comes from.

Most teams optimize the first and ignore the second. The brands that get cited do both, and they make sure the two never disagree. If your feed says one price and your page says another, you have taught the engine that your data is unreliable, and an engine that distrusts your facts will quietly route around you.

## What to mark up: the fields that matter.

Use the `Product` type and prioritize the properties an AI answer leads with. In rough order of impact:

- **name, brand, image.** The basics, but `brand` is load-bearing: it ties the product to a known entity the engine may already trust.
- **description.** Write it as a real answer, not a keyword list. This is text the engine can quote directly.
- **offers (Offer or AggregateOffer).** `price`, `priceCurrency`, and `availability` are the fields AI shopping answers surface first. Include `priceValidUntil` and `url`.
- **aggregateRating and review.** Real ratings and a few `Review` items give the engine the trust signal it weighs heavily. These must reflect reviews a human can actually see on the page.
- **gtin, mpn, sku.** The match keys. `GTIN` and `MPN` let an engine recognize that your product is the same item listed and reviewed elsewhere, and they are what Merchant listings rely on.

Here is a minimal, well-formed example you can adapt. This is a teaching sample only:

```json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Acme Trail Runner 2",
  "image": "https://example.com/img/trail-runner-2.jpg",
  "description": "Lightweight trail running shoe with a 6mm drop and a grippy outsole for wet rock.",
  "brand": { "@type": "Brand", "name": "Acme" },
  "sku": "ATR2-BLK-10",
  "gtin13": "0123456789012",
  "mpn": "ATR2-BLK",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "214"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/products/trail-runner-2",
    "priceCurrency": "USD",
    "price": "128.00",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  }
}
```

Every value in that block should match what a shopper sees on the page. The schema is a mirror of the page, never a wish list. The broader pattern for connecting product, brand, and review entities with stable `@id` references is in [schema markup for AI engines](/playbooks/schema-markup-for-ai-engines-2026/).

## Common mistakes that get your markup ignored.

| Mistake | What the engine does | Fix |
| --- | --- | --- |
| Schema price does not match visible price | Distrusts the page, may drop it | Render price once, reference it in both |
| Missing or stale availability | Treats stock as unknown, deprioritizes | Keep availability live from inventory |
| aggregateRating with no real reviews | Risks a penalty and lost trust | Only mark up ratings shown on page |
| No GTIN or MPN | Cannot match product across the web | Add identifiers to every variant |
| Category page marked as one Product | Markup invalid, ignored | One Product block per product page |
| Schema injected client-side only | Crawler may never execute it | Server-render the JSON-LD |

The thread running through all of these: an AI engine is deciding whether to stake its answer on your data. Anything that looks fabricated, mismatched, or unreadable is a reason to pick a competitor whose facts line up.

## Feeds versus on-page: how the work splits.

These are not competing options. They serve different surfaces and you need both.

- **The product feed** (Merchant Center and the merchant programs the AI engines ingest) powers structured shopping listings, the comparison grids, and price-led product cards. Its currency is identifiers and clean attributes.
- **On-page Product schema** powers the organic citation, the moment an engine reads your page directly and decides to name you with a link. Its currency is accuracy and quotable copy.

The operational rule is one source of truth. Your price, availability, and rating should originate in one system and flow to both the feed and the page schema, so they can never drift apart. When they match, every surface reinforces the same facts, and reinforcement is what builds the engine's confidence to cite you. For the product-page citation playbook end to end, see [ecommerce GEO and product citations](/playbooks/ecommerce-geo-product-citations/).

## Connect Product schema to your other entities.

A floating `Product` block works, but a connected one works harder. Reference your `brand` as a real entity, tie reviews to the product, and make sure the organization behind the store is itself a verifiable entity with consistent identifiers. If you sell from a physical location as well, the same entity-graph discipline applies to your storefront; the local pattern is covered in the [local business schema guide](/playbooks/local-business-schema-guide/). The goal is a web of stable references an engine can traverse: this product, made by this brand, sold by this verifiable business, rated by these real reviews.

## Where this fits in GEO.

Product schema is the product-level expression of generative engine optimization. GEO is the practice of being the source an AI engine trusts enough to cite; for an ecommerce brand, the unit of that trust is the individual product. Schema hands the engine machine-readable facts, the surrounding copy hands it language to lift, and consistent identifiers let it confirm your product against listings and reviews elsewhere. None of those work in isolation. They work together, which is why product schema is a tactic inside a strategy, not a checkbox. The full strategy lives in our [generative engine optimization service](/services/generative-engine-optimization/).

## Frequently asked questions.

**What is Product schema and why does it matter for AI shopping?**

Product schema is structured data (in JSON-LD) that describes a product to machines: its name, brand, identifiers (GTIN, MPN), an Offer with price and availability, and aggregate ratings or reviews. It matters for AI shopping because engines like ChatGPT shopping, Gemini, Perplexity, and Google AI Overviews assemble product answers from sources they can parse and trust. When your price, availability, rating, and identifiers are stated in schema, the engine can read them with confidence and is more likely to surface and cite your product instead of guessing or skipping it.

**Which Product schema properties matter most for getting cited?**

Start with the ones that answer a shopper's question directly: name, brand, image, and a description that reads like a real answer. Then the Offer block with price, priceCurrency, and availability, because AI shopping answers lead with price and stock. Then trust signals: aggregateRating and individual Review items. Finally the identifiers, GTIN, MPN, and brand, which let an engine match your product to the same item across the web and into Merchant listings. Identifiers plus a valid Offer are what separate a product an engine will name from one it will ignore.

**Should I rely on a product feed or on-page Product schema?**

Use both, because they feed different surfaces. A product feed (Google Merchant Center, and the merchant programs the AI engines pull from) powers shopping listings, price comparisons, and the structured product cards. On-page Product schema powers the organic citation: when an engine reads your product page directly, it needs the same facts in JSON-LD. The failure mode is mismatch, a feed that says one price and a page that says another. Keep them in sync, ideally from one source of truth, so every surface tells the engine the same story.

**What are the most common Product schema mistakes?**

The frequent ones: a price in the schema that does not match the visible price on the page, a missing or stale availability value, fabricated or self-serving aggregateRating that no real reviews support, omitting GTIN and MPN so engines cannot match the product, marking up a category or collection page as a single Product, and injecting the schema with client-side JavaScript that crawlers may not execute. Each of these either gets the markup ignored or, worse, makes the engine distrust the page. Stated facts must match what a human sees, and the markup should be server-rendered.

**How does Product schema connect to GEO?**

Product schema is the product-level expression of generative engine optimization. GEO is about being the source an AI engine trusts and cites; for ecommerce, the unit of that trust is the individual product. Schema gives the engine machine-readable facts, citable on-page copy gives it language to lift, and consistent identifiers let it tie your product to reviews and listings elsewhere. The schema does not work alone, it works because the surrounding page is written to be quoted and the product is verifiable across the web.