Schema markup for ecommerce means adding Product, Offer, AggregateRating, Review, and ItemList JSON-LD to your store so Google and AI shopping assistants can read the price, availability, and star rating directly from your code. Product pages need Product plus a nested Offer; category pages need ItemList; reviews need AggregateRating or Review, or both. Get the required properties right and you become eligible for price, shipping, and rating enhancements in search results.
Ecommerce schema markup is different because it has to describe a transaction, not just an article. A blog post needs a headline and an author. A product page needs a price that stays accurate, a stock status that changes hourly, and a rating built from real buyers, and Google checks all three against what a shopper actually sees on the page. That is why a general WordPress schema setup, the kind covered in our guide on how to add schema markup in WordPress, is not enough on its own for a shop: it gets Article and Organization schema right but rarely configures Product, Offer, and AggregateRating with the depth an online store needs.
The two documents work together rather than replacing each other. That guide covers the platform mechanics: plugins, JSON-LD in functions.php, and the general schema types every WordPress site should have. This one covers the ecommerce-specific types layered on top: which schema fits a product page versus a category page, the exact required properties Google checks, and the mistakes that quietly disqualify a store from rich results.
Use this table before you write a single line of JSON-LD. Matching the wrong type to a page, such as putting Product schema on a category listing, is one of the most common reasons ecommerce structured data fails validation or gets ignored.
| Page type | Schema type to use | Why this type |
|---|---|---|
| Single product detail page | Product + nested Offer | Google's ecommerce structured data guide names Product as the primary type for an individual item |
| Product with size, color, or material variants | ProductGroup + variesBy | Keeps one price and stock level per real variant instead of one number for the whole family |
| Category or collection page listing many products | ItemList, each product as a ListItem | Google's carousel guidelines require list items to be the same type; full Product markup per item is unnecessary here |
| Standalone review or comparison content | Review, with itemReviewed pointing to the product | Editorial review pages qualify for the Product snippet track, including pros and cons |
| Star rating summary on a product page | AggregateRating, nested inside Product | Requires ratingValue and at least ratingCount or reviewCount to show stars |
| Category to product navigation trail | BreadcrumbList | Clarifies site hierarchy for search and AI crawlers, independent of the product data itself |
| Physical store location tied to the catalog | LocalBusiness | Needed separately from Product when the store also has a walk-in location |
Google splits Product structured data into two eligibility tracks with different required fields: Product snippets and Merchant listings. A page can only earn merchant-listing features, like the price and shipping badges, if it meets the merchant listing bar, not the lighter snippet bar.
For a Product snippet (pages that discuss a product without necessarily selling it, like an editorial review), Google requires the name property plus at least one of review, aggregateRating, or offers.
For a Merchant listing (pages where a shopper can actually buy the item), Google requires name, image, and a nested offers object, and inside that offer it requires price (must be greater than zero) and priceCurrency in ISO 4217 format such as USD. Everything past that, including brand, sku, gtin or gtin13, mpn, aggregateRating, review, availability, itemCondition, priceValidUntil, shippingDetails, and hasMerchantReturnPolicy, is recommended, not required. Recommended does real work though: Google says explicitly that the more of these you add, the more enhancements the page becomes eligible for.
Here is a complete, valid merchant listing example for a single product page. Shown as plain text so you can copy it, not as live markup on this page:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Nomad 32L Waterproof Backpack",
"image": [
"https://example.com/img/nomad-backpack-1x1.jpg",
"https://example.com/img/nomad-backpack-4x3.jpg",
"https://example.com/img/nomad-backpack-16x9.jpg"
],
"description": "32-liter waterproof daypack with a padded 15-inch laptop sleeve and roll-top closure.",
"sku": "NMD-BP-32-BLK",
"gtin13": "0194252123456",
"brand": {
"@type": "Brand",
"name": "Nomad Gear"
},
"offers": {
"@type": "Offer",
"url": "https://example.com/products/nomad-32l-backpack",
"priceCurrency": "USD",
"price": "89.00",
"priceValidUntil": "2026-12-31",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition",
"shippingDetails": {
"@type": "OfferShippingDetails",
"shippingRate": {
"@type": "MonetaryAmount",
"value": "0.00",
"currency": "USD"
},
"shippingDestination": {
"@type": "DefinedRegion",
"addressCountry": "US"
}
},
"hasMerchantReturnPolicy": {
"@type": "MerchantReturnPolicy",
"returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
"merchantReturnDays": 30,
"returnMethod": "https://schema.org/ReturnByMail",
"returnFees": "https://schema.org/FreeReturn"
}
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.6",
"reviewCount": "128"
},
"review": [
{
"@type": "Review",
"reviewRating": {
"@type": "Rating",
"ratingValue": "5"
},
"author": {
"@type": "Person",
"name": "Alex R."
},
"reviewBody": "Held up through two weeks of daily commuting in the rain, nothing leaked through."
}
]
}
</script>A Product snippet and a Merchant listing look similar in the JSON-LD but are judged by different rules and unlock different search features. Mixing them up is why some stores add full schema and still never see a price or shipping badge.
In practice: a "best backpacks for commuters" roundup post is a Product snippet candidate. Your own /products/nomad-32l-backpack page, where someone can add the item to a cart, is a merchant listing candidate and needs the stricter required fields to unlock price and shipping display.
AggregateRating summarizes many ratings into one average and requires ratingValue plus at least one of ratingCount or reviewCount, nested inside the Product it describes. Review schema marks up individual write-ups and requires an author, a reviewRating with a ratingValue, and either nesting inside the reviewed item or an explicit itemReviewed property.
The rule that trips up the most stores: Google's structured data policies explicitly forbid aggregating reviews or ratings pulled in from other websites into your own AggregateRating markup. The ratings have to come from people who actually reviewed your product on your site. Google also disqualifies self-serving reviews where the entity being reviewed controls the review content, which mainly affects Organization and LocalBusiness listings rather than individual products, but the underlying principle is the same across every type Google supports for star ratings: Book, Course, Event, Game, HowTo, LocalBusiness, MediaObject, Movie, MusicPlaylist, MusicRecording, Organization, Product, Recipe, and SoftwareApplication.
If your platform pulls in reviews from a third-party marketplace or a syndicated feed, do not fold those into your own AggregateRating block. Either omit ratings for that product or wait until you have enough on-site reviews to build a legitimate average. A fabricated or borrowed rating that gets caught is a manual action risk, not just a missed rich result.
Category pages should use ItemList, with each product represented as a ListItem that links to its own product URL, not full Product schema repeated for every item on the page. Google's carousel structured data guidelines require every item in the list to be the same content type and require at least two ListItem entries for the markup to be valid.
Wrap the ItemList inside a CollectionPage and connect the two with the mainEntity property so search engines understand the list is the primary content of that URL. Keep the order of items in the markup identical to the order shoppers actually see, since Google can ignore structured data that does not match the visible page.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "CollectionPage",
"name": "Waterproof Backpacks",
"mainEntity": {
"@type": "ItemList",
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"url": "https://example.com/products/nomad-32l-backpack"
},
{
"@type": "ListItem",
"position": 2,
"url": "https://example.com/products/trailhead-28l-backpack"
},
{
"@type": "ListItem",
"position": 3,
"url": "https://example.com/products/summit-40l-backpack"
}
]
}
}
</script>Beyond the individual product page, a functioning ecommerce schema setup needs four building blocks working together across the whole site, not just one template.
Google's own ecommerce structured data guidance also calls out Organization schema for sitewide business details like logo and return policy, and VideoObject for product demo videos, but Product, ItemList, Review or AggregateRating, and BreadcrumbList are the four that touch nearly every page template on a typical store.
Most ecommerce schema failures come from a small set of repeat mistakes rather than exotic edge cases.
Test every template, not just one product, using two free tools before you trust the markup. Paste a live product URL into Google's Rich Results Test to see exactly which enhancements the page qualifies for and which required properties are missing. Then run the same JSON-LD through the Schema Markup Validator at validator.schema.org to check it against the broader Schema.org vocabulary, which covers properties Google does not surface as a rich result but that AI systems may still read. For an ongoing check without pasting URLs one at a time, our own JSON-LD schema checker validates the raw markup and flags missing required fields before you push a template change live.
After launch, watch the structured data reports in Search Console for a few weeks. Errors that only surface once Google recrawls a large catalog, like a plugin update silently dropping priceCurrency across every product, are the ones that do the most damage because they go unnoticed the longest.
Hand-writing JSON-LD for a catalog of thousands of SKUs is not realistic, and it is not what most stores actually do. Shopify, WooCommerce, and BigCommerce all generate baseline Product schema automatically from your existing product data, so the practical work is auditing what the platform already outputs against the required and recommended properties above, then patching the gaps, usually AggregateRating, GTIN, and shippingDetails, which platforms handle inconsistently. For the pieces that need a manual patch, our product schema generator and review schema generator produce clean JSON-LD for a single product or review without touching a template file, and our Organization schema generator covers the sitewide business details Google asks for separately from any individual product.
If schema is one symptom of a bigger technical gap, mismatched titles, a missing sitemap, slow product pages, our ecommerce SEO services cover the catalog end to end rather than patching one template at a time.
What is schema markup for ecommerce? Schema markup for ecommerce is structured data, usually JSON-LD, that tells Google and AI engines exactly what a product page or category page contains: a product's name, price, availability, and reviews. It uses vocabulary from Schema.org so the properties are machine-readable rather than guessed from surrounding text. On an online store it mainly means Product, Offer, AggregateRating, Review, and ItemList markup.
Which schema type should a product page use? A single product page should use Product structured data with a nested Offer for price and availability. If the item has variants like size or color, use ProductGroup with a variesBy property instead, and mark each variant as a separate Product inside it. Google's own ecommerce structured data guide names Product and ProductGroup as the two page-level types for individual items.
Do I need AggregateRating or Review schema, or both? You need at least one. Google's Review snippet documentation requires either AggregateRating or individual Review objects nested inside your Product, and AggregateRating specifically requires ratingValue plus at least one of ratingCount or reviewCount. Most stores use AggregateRating for the overall star average and add a handful of individual Review entries underneath it.
What is the difference between Product snippet and Merchant listing schema? A Product snippet is for pages that discuss a product without necessarily selling it, such as an editorial review, and only requires a name plus one of review, aggregateRating, or offers. A Merchant listing is for pages where a shopper can actually buy the item, and Google requires name, image, and a nested Offer with price and priceCurrency. Only merchant listings are eligible for the free-shipping and price-drop badges.
What schema should ecommerce category pages use? Category and collection pages that list several products should use ItemList, with each product represented as a ListItem pointing to its own product URL. Google's carousel guidelines require every item in the list to be the same type and require at least two ListItem entries. Do not put full Product markup for every item directly on the category page; link out to the product pages instead.
What are the required properties for Product schema in Google? For a merchant listing, Google's structured data guidelines require name, image, and offers at the Product level, and price plus priceCurrency inside the nested Offer, with price greater than zero. Everything else, including brand, sku, gtin, availability, itemCondition, shippingDetails, and hasMerchantReturnPolicy, is recommended rather than required, though adding more of them increases which rich result features the page can qualify for.
Can I add reviews from other websites to my AggregateRating schema? No. Google's structured data policies explicitly prohibit aggregating reviews or ratings pulled from other websites into your own AggregateRating markup. Ratings must come directly from your own customers reviewing your own product, and Google also disqualifies self-serving reviews where the entity being reviewed controls the review content for its own Organization or LocalBusiness listing.
Does schema markup guarantee rich results on Google? No. Valid Product schema makes a page eligible for star ratings, price, and shipping details in search results, but Google decides case by case whether to actually display them, and eligibility can change without notice. Adding the markup is necessary but not sufficient; the page still needs to satisfy Google's general content and quality guidelines for the enhancement to appear.
How do I test ecommerce schema markup before publishing? Paste the live product URL or raw JSON-LD into Google's Rich Results Test to see which enhancements it qualifies for and to catch missing required properties. Then run the same markup through the Schema Markup Validator at validator.schema.org to check it against the full Schema.org vocabulary, since that tool covers properties Google does not surface as a rich result. Recheck after any theme or plugin update.
Do variant products need separate schema? Yes, when a product comes in different sizes, colors, or materials, wrap the family in ProductGroup and list each variant as its own Product with a distinct sku and url, connected through the variesBy property. Marking every variant as one generic Product with a single price hides the real availability and pricing differences from Google and from AI shopping assistants.
Start with the decision table: confirm every product, category, and review page on your store is wearing the right schema type before you touch a single property. Then check your merchant listings against the required fields, name, image, offers with price and priceCurrency, and layer in the recommended ones that matter most for your catalog, usually AggregateRating and shippingDetails. If you would rather have someone audit the whole catalog's structured data at once, request a free SEO audit from Rankite and we will show you exactly which templates are leaving rich results on the table.
Get a free, no-obligation SEO audit and a 30-minute strategy session. We'll show you exactly where the growth is hiding.
Fill out the form and we'll get back to you within one business day. Prefer email? Write to us directly at contact@rankite.com.