Product Structured Data for Google Shopping: The Complete Guide (2026)

Updated June 2026 • 9 min read

Google's Shopping crawler does two things when it visits your product pages. It reads the rendered HTML to extract prices, availability, and product details. And it looks for machine-readable schema.org markup that gives it the same information in a structured format it can parse reliably. When that structured data is present and correct, Google can validate your products faster, surface them in rich result formats, and avoid the price mismatch errors that lead to disapprovals.

This guide covers how to implement Product structured data correctly, what each field does, how to test your implementation, and the specific errors that cause problems in Google Merchant Center.

Why Structured Data Matters for Google Shopping

Google's crawler uses schema.org Product markup to understand your products, cross-validate the prices and availability it finds in your feed, and qualify pages for rich result features. There are three concrete benefits for merchants.

First, structured data reduces price crawl errors. When your product page renders the price via JavaScript, Google's crawler may not execute the script and reads no price. If the structured data contains the correct price in a machine-readable format, Google can read that instead. A missing price on the crawled page is one of the most common triggers for price mismatch disapprovals in Merchant Center. Structured data eliminates this failure mode.

Second, it qualifies products for Shopping rich results. Product carousels in Google Search, product knowledge panels, and price drop notifications all require valid Product schema. Without it, your products appear only as standard Shopping ads, missing the higher-visibility placements that structured data unlocks.

Third, if you implement AggregateRating markup, your products become eligible for star rating display in Google Shopping results. Star ratings increase click-through rates noticeably, and the only way to get them is through valid structured data or a Google-approved review aggregator integration.

Required Product Schema Properties

Google specifies a set of required and recommended properties for Product markup. The following are the fields you need for Shopping compatibility.

name — The product name as it appears on the page. This should match or closely align with the title attribute in your feed.

image — A URL pointing to the primary product image. Use an absolute URL, not a relative path. Google recommends images that are at least 50x50 pixels; larger images render better in rich results.

description — A brief product description. Not strictly required for all rich result types, but recommended for Shopping and product knowledge panels.

sku or mpn — A unique product identifier. SKU is your internal stock-keeping unit. MPN (Manufacturer Part Number) is the manufacturer's identifier. Providing one of these is required for Google Shopping eligibility. If you have both, include both.

brand — The brand or manufacturer name. Set as a nested Brand object with a name property.

offers — The Offer object that contains price, availability, and purchase details. This is the most critical block for Shopping compliance.

The Offer Schema in Detail

The offers property takes either a single Offer object or an AggregateOffer for products with multiple price points. For standard e-commerce products, use a single Offer.

price — The numeric price value. This must be a number, not a formatted string. Write "price": "29.99", not "price": "29.99 EUR" or "price": "€29.99". The currency goes in a separate field. The price here must match the price in your Merchant Center feed exactly, including decimal places. A feed price of 29.99 and a schema price of 30 is a mismatch and will trigger a disapproval.

priceCurrency — The ISO 4217 three-letter currency code: EUR, USD, GBP, and so on. This must match the currency in your feed for the target market.

availability — One of the schema.org availability URLs. Use https://schema.org/InStock for products available to purchase, https://schema.org/OutOfStock for unavailable products, and https://schema.org/PreOrder for products not yet released. The availability value here must match the availability attribute in your feed. A schema that says InStock while your feed says out_of_stock causes a disapproval.

url — The canonical URL of the product page. Use an absolute URL that matches your feed's link attribute.

priceValidUntil — Required when you have a sale or promotional price. Set this to the date the promotional price ends, formatted as YYYY-MM-DD. When the sale ends and you revert to the regular price, update both the schema and the feed at the same time. If priceValidUntil is in the past and the price has changed, Google treats the previous price as expired and may read the page price as different from the feed.

itemCondition — Indicates whether the product is new, used, or refurbished. Values: https://schema.org/NewCondition, https://schema.org/UsedCondition, https://schema.org/RefurbishedCondition. Required for marketplaces and recommended for all retailers. This must match the condition attribute in your feed.

AggregateRating: How to Enable Star Ratings

Adding AggregateRating markup to your Product schema tells Google the overall rating of the product and how many reviews it is based on. When present and valid, this qualifies your products for star rating display in Google Shopping and organic product results.

ratingValue — The average rating on a scale from 1 to 5. Use a decimal value: "ratingValue": "4.3".

reviewCount — The number of reviews that the rating is based on. Google requires at least a small number of reviews for the star rating to appear in results.

The rating data must reflect real customer reviews. Google cross-checks AggregateRating values against known review sources and will suppress or penalize inflated or fabricated ratings. The reviewCount should be accurate, not a static placeholder.

Implementation Methods

There are three ways to add structured data to a page: JSON-LD, Microdata, and RDFa. JSON-LD is the recommended approach for every e-commerce platform.

JSON-LD is a script block added to the <head> section of the page. It is completely separate from the visible HTML, which means it is easy to update without touching the page layout. Google's crawler reads JSON-LD before rendering the full page, making it more reliable than HTML-embedded methods when crawlers have limited rendering capacity. All major e-commerce platforms (Shopify, WooCommerce, Magento, BigCommerce) support JSON-LD injection natively or via plugins.

Microdata embeds the schema properties directly in the HTML using attributes like itemprop and itemscope. It works but creates a tight coupling between your markup and your page layout. Changes to the page design can accidentally break the structured data. Avoid Microdata for new implementations.

RDFa is a third format that works similarly to Microdata. It is rarely used in e-commerce and has no practical advantages over JSON-LD for this use case.

Working JSON-LD Template

Copy this template into your <head> and replace the placeholder values with your actual product data:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Your Product Name",
  "image": "https://www.yourstore.com/images/product-main.jpg",
  "description": "A clear description of what the product is and does.",
  "sku": "SKU-12345",
  "mpn": "MPN-67890",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand Name"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.yourstore.com/products/your-product",
    "price": "49.99",
    "priceCurrency": "EUR",
    "priceValidUntil": "2027-01-01",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.5",
    "reviewCount": "128"
  }
}
</script>

For dynamic product pages, your platform or backend should generate this block with real product values rather than serving a static template. The price, availability, and priceValidUntil values should update automatically when product data changes.

Testing Your Structured Data

Three tools should be part of your implementation workflow.

Google Rich Results Test (search.google.com/test/rich-results) shows you which rich result types your page qualifies for based on its structured data. It renders the page the way Googlebot does and parses the schema. Any errors or missing required fields appear in the results. Run this test on every product page template, not just one example product.

Schema Markup Validator (validator.schema.org) validates your JSON-LD against the schema.org specification. It is broader than the Rich Results Test and catches property naming errors, wrong data types, and missing fields that Google's tool may not surface directly.

GMC Diagnostics tab surfaces schema-related mismatches after Google has crawled your pages. Navigate to Products, then Diagnostics in Merchant Center. The diagnostics tab flags cases where your structured data price does not match your feed price, where availability signals conflict, or where required schema properties are missing. This is the authoritative view of what Google sees once your pages are live, not just what your code generates.

Common Errors That Cause Disapprovals

Price in schema does not match price in feed. The most common cause of structured-data-related disapprovals. Both values must be identical numerically and in the same currency. A feed price of 19.99 EUR and a schema price of 19.99 with priceCurrency: "USD" is a mismatch. So is a schema price of 19 when the feed says 19.99. Generate schema values from the same source of truth your feed generator uses, not from a separate hard-coded value.

Availability schema says InStock but feed says out of stock. If a product sells out and you update your feed but not your schema, or vice versa, Google detects the conflict and can disapprove the product. Availability updates in schema must be triggered by the same event that updates your feed. For platforms using the Content API for real-time price updates, include an availability update in the same API call.

priceValidUntil in the past with an unchanged price. If your schema still contains a priceValidUntil date from a promotion that ended months ago, Google may treat the current price as unvalidated. Remove the priceValidUntil field for regular (non-promotional) prices, or update it to a future date that reflects your intended price floor.

Schema on page does not match what the user sees. If your page renders a different price to users than what appears in the structured data, Google detects the mismatch during crawling. This sometimes happens when sites show geolocation-based pricing or currency switching that affects rendered prices but not the server-generated schema block. Test from a neutral IP address to confirm the schema and visible price are consistent.

Audit Your Full GMC Setup

Structured data errors are one of several categories that lead to product disapprovals and account suspensions in Google Merchant Center. The GMCSuspension.com audit tool checks your Merchant Center setup against 52 policy requirements, including feed formatting, landing page compliance, price configuration, and structured data signals. Run a free audit to identify every issue affecting your Shopping visibility across your full product catalog.