Product schema markup. Five layered types. One complete reference.

Why schema matters in 2026

Product schema markup has matured from a nice-to-have SEO enhancement to a foundational requirement for product discovery. The reasons compound across traditional search, Google Shopping, and the emerging AI search layer.

Traditional Google search benefits

• Rich results in search — star ratings, prices, availability, and review snippets appear directly in Google search results. Brands with complete schema get richer search appearances that drive 15-30% CTR lift over plain blue links
• Google Shopping eligibility — free Google Shopping listings require complete Product, Offer, ShippingDetails, and hasMerchantReturnPolicy schema. Brands without complete schema get restricted Shopping visibility
• Featured snippets and knowledge panels — FAQ schema drives FAQ rich results; AggregateRating drives star displays; Review schema enables review snippet displays

AI search citation eligibility

The newer and increasingly important benefit: AI search engines cite products with complete schema markup more reliably. ChatGPT shopping queries evaluate product schema when generating responses; brands with weak schema get cited less frequently. Perplexity citation logic weights structured data heavily; AI engines prefer unambiguous schema-defined product data over inferred-from-HTML data. Alexa for Shopping (formerly Rufus) treats product schema as primary citation source for Amazon-related and general product queries. As AI search captures an estimated 15-30% of shopping discovery traffic by late 2026, schema-driven citation eligibility becomes a major competitive advantage.

The compound effect on conversion

Schema improvements don't just drive traffic — they drive higher-quality traffic. Rich results pre-qualify shoppers (star rating visible before clicking = shopper expectations set). Shopping listings show prices and shipping (shopper price comparison happens before click). AI citations include product context (shopper arrives informed). The result: brands with strong schema typically see 8-15% higher conversion rates on schema-driven traffic vs generic search traffic.

The compounding error reality

Most brands have schema implementations that contain silent errors. Theme updates break custom schema. Reviews app changes invalidate AggregateRating. Google introduces new properties (ShippingDetails 2022, hasMerchantReturnPolicy 2023) that brands miss. The result: brands assume their schema works while it silently underperforms. Periodic schema audits catch the accumulated drift — we typically find 40-70% of brands have material schema errors when first audited.

The implementation discipline matters

Schema can be implemented well or poorly with similar surface appearance. Both might "have product schema" but only one passes validation, drives rich results, and supports AI citation. The implementation quality multiplier is meaningful: well-implemented schema delivers full benefits; poorly-implemented schema may deliver 20-40% of potential benefits while appearing to work.

The 5-type schema hierarchy

Ecommerce product schema is not a single schema type — it's a layered architecture of five interrelated types. Understanding the hierarchy matters because the types nest within each other and depend on each other for complete coverage.

The nesting architecture

Offer schema nests inside Product schema as the offers property. AggregateRating nests inside Product as the aggregateRating property. Review nests inside Product as the review property (an array of Review objects). FAQ schema is separate (typed as FAQPage, not nested in Product) but appears on the same page and references the same product context. The nesting matters because schema validators check the nested structure — orphaned Review schema (not nested in Product) often fails validation.

What each type unlocks

• Product alone: basic search result enhancement, product name and brand display
• Product + Offer: price display in search results, Google Shopping eligibility, shipping/return display
• Product + Offer + AggregateRating: star ratings in search snippets, "X reviews" display
• Product + Offer + AggregateRating + Review: review snippets with specific reviewer quotes in search
• All 5 (with FAQ): FAQ rich results, complete AI citation eligibility, fullest search appearance

The minimum vs complete schema tradeoff

Many brands implement only Product + basic Offer schema thinking that's "enough." The minimum-schema approach gets some benefits but misses the compounding effects of complete schema. Complete schema (all 5 types) is 30-40% more implementation work than minimum schema but delivers 2-3x the search benefit. The investment-to-payback ratio strongly favors complete implementation.

Product schema implementation

Product schema is the foundational layer. Every product page should have complete Product schema in JSON-LD format embedded in the page head. The properties shown below cover required, strongly-recommended, and optional fields for ecommerce.

Required Product schema properties

• name — the product name as it appears on the product page
• image — one or more product images (high-resolution preferred). Array of image URLs
• description — product description (typically 50-200 words). Should match visible page description

Strongly-recommended Product schema properties

• brand — the brand name with Brand schema nested ({"@type": "Brand", "name": "BrandName"})
• sku — your internal SKU identifier
• gtin — Global Trade Item Number (UPC/EAN). Use gtin8, gtin12, gtin13, or gtin14 based on code type
• mpn — Manufacturer Part Number if different from SKU
• category — Google product category or your category taxonomy

Product attribute properties

• color — product color (single value or array for color options)
• material — primary material composition
• size — size designation (use Schema.org standardized values when applicable)
• weight — with QuantitativeValue nested object containing value and unitCode
• height/width/depth — product dimensions with QuantitativeValue objects

Example complete Product schema (JSON-LD)

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Wireless Noise-Cancelling Earbuds",
  "image": [
    "https://example.com/earbuds-1.jpg",
    "https://example.com/earbuds-2.jpg",
    "https://example.com/earbuds-3.jpg"
  ],
  "description": "Premium wireless earbuds with active noise cancellation, 30-hour battery life, and IPX5 water resistance. Includes wireless charging case.",
  "brand": {
    "@type": "Brand",
    "name": "BrandName"
  },
  "sku": "WNC-EB-001",
  "gtin13": "0123456789012",
  "mpn": "WNC-EB-001-BLK",
  "category": "Electronics > Audio > Headphones > Earbuds",
  "color": "Black",
  "material": "Plastic, Silicone",
  "weight": {
    "@type": "QuantitativeValue",
    "value": "50",
    "unitCode": "GRM"
  }
  // Offer, AggregateRating, Review nested here
}
</script>

The GTIN priority

Google strongly prefers GTIN identifiers. Products with valid GTINs get better rich result eligibility, more accurate product matching across the web, and stronger AI search citation confidence. If your products lack GTINs (private label, custom products), add the identifierExists property set to false to explicitly indicate no GTIN exists. Don't omit the identifier discussion entirely — Google interprets missing identifier signals negatively.

Image schema best practices

Provide multiple high-resolution images (1200x1200 minimum). Use absolute URLs, not relative paths. The first image should be the primary product image. Include lifestyle and detail images in the array. Image URLs must be publicly accessible (no auth required). Google's product image guidelines prefer white-background catalog images plus lifestyle context images.

Offer schema: pricing & shipping

Offer schema nests inside Product schema as the offers property. Defines everything about the commercial transaction — price, availability, shipping, returns. Critical for Google Shopping eligibility and price displays in search.

Core Offer properties

• price — numeric price value (no currency symbol)
• priceCurrency — 3-letter ISO 4217 currency code (USD, CAD, GBP, EUR, etc.)
• availability — specific Schema.org values only: InStock, OutOfStock, PreOrder, Discontinued, BackOrder, LimitedAvailability, SoldOut
• priceValidUntil — date through which price is valid (ISO 8601 format)
• url — canonical product URL
• seller — Organization schema with seller name

ShippingDetails (2022 expansion)

Added by Google in 2022, ShippingDetails defines shipping costs and delivery times for Google Shopping. Properties include shippingRate (cost as MonetaryAmount), shippingDestination (geographic coverage), deliveryTime with handlingTime and transitTime sub-properties, and shippingLabel for descriptive shipping options. Brands without ShippingDetails show generic "Shipping calculated at checkout" while competitors with ShippingDetails show specific costs and times.

hasMerchantReturnPolicy (2023 requirement)

Added by Google in 2023 and now required for free Google Shopping listings. Defines return window and policy. Properties: applicableCountry, returnPolicyCategory (one of MerchantReturnFiniteReturnWindow, MerchantReturnNotPermitted, MerchantReturnUnspecified, MerchantReturnUnlimitedWindow), merchantReturnDays (for finite windows). Most ecommerce uses MerchantReturnFiniteReturnWindow with 30-day windows.

Example complete Offer schema

"offers": {
  "@type": "Offer",
  "price": "199.99",
  "priceCurrency": "USD",
  "priceValidUntil": "2026-12-31",
  "availability": "https://schema.org/InStock",
  "url": "https://example.com/products/wireless-earbuds",
  "seller": {
    "@type": "Organization",
    "name": "BrandName Store"
  },
  "shippingDetails": {
    "@type": "OfferShippingDetails",
    "shippingRate": {
      "@type": "MonetaryAmount",
      "value": "0",
      "currency": "USD"
    },
    "shippingDestination": {
      "@type": "DefinedRegion",
      "addressCountry": "US"
    },
    "deliveryTime": {
      "@type": "ShippingDeliveryTime",
      "handlingTime": {
        "@type": "QuantitativeValue",
        "minValue": "0",
        "maxValue": "1",
        "unitCode": "DAY"
      },
      "transitTime": {
        "@type": "QuantitativeValue",
        "minValue": "1",
        "maxValue": "3",
        "unitCode": "DAY"
      }
    }
  },
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "applicableCountry": "US",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": "30",
    "returnMethod": "https://schema.org/ReturnByMail",
    "returnFees": "https://schema.org/FreeReturn"
  }
}

Multi-currency / multi-region scenarios

Brands selling internationally need separate Offer schemas per region or AggregateOffer schema covering multiple offers. Common implementation: per-page schema reflecting the current visitor's region (geo-targeted), with hreflang tags coordinating multi-language/region versions. Validate that priceCurrency matches the actual checkout currency — mismatches cause Google Shopping rejections.

The availability values reality

Common error: using custom availability values like "Available" or "In Stock" (free text). Schema.org requires specific URL-based values: https://schema.org/InStock, https://schema.org/OutOfStock, etc. The full URL form is preferred. Custom strings break validation silently — the schema appears to work but doesn't drive rich results.

AggregateRating & Review schema

AggregateRating provides the aggregate star display in search results. Review provides individual review snippets. Both nest inside Product schema and together drive review-related rich results.

AggregateRating schema

• ratingValue — average rating (e.g., 4.7). Decimal allowed
• reviewCount — total number of reviews
• bestRating — maximum possible rating (typically 5)
• worstRating — minimum possible rating (typically 1)

Example AggregateRating

"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.7",
  "reviewCount": "1247",
  "bestRating": "5",
  "worstRating": "1"
}

Review schema (individual reviews)

Embed 3-5 highest-quality reviews per product. Each Review needs:

• author — Person schema with name (use first name + last initial for privacy)
• datePublished — ISO 8601 date
• reviewBody — the review text content
• reviewRating — Rating sub-schema with ratingValue

Example Review array

"review": [
  {
    "@type": "Review",
    "author": {
      "@type": "Person",
      "name": "Sarah M."
    },
    "datePublished": "2026-06-15",
    "reviewBody": "Best earbuds I've owned. Battery lasts all day, noise cancelling is incredible on flights. Sound quality matches my over-ear cans.",
    "reviewRating": {
      "@type": "Rating",
      "ratingValue": "5",
      "bestRating": "5"
    }
  }
  // Add 2-4 more high-quality reviews
]

Source-of-truth integration

AggregateRating and Review schema should reflect actual reviews data from your reviews platform (Judge.me, Yotpo, Okendo, Stamped, Junip). Most reviews apps inject this schema automatically. Validate that the injected schema matches your actual ratings — common drift: review app sync issues create schema with outdated review counts or ratings.

The fake review prohibition

Schema markup must reflect real reviews. Fake AggregateRating (inflated ratings without actual reviews backing them) violates Google's spam policies and can result in manual penalties. Schema is enforceable; faking it creates risk that compounds across all your schema-driven traffic. Always tie schema to actual reviews data from your platform.

Embedded vs separate review sources

Two approaches exist. Embedded reviews: review content lives in your product page (visible content) and matches schema. Most common and Google-preferred approach. External review aggregators: AggregateRating can reference reviews on external platforms with proper sourcing schema. Less common, more complex validation. For most ecommerce, embedded reviews with reviews app integration is the right approach.

FAQ schema for ecommerce

FAQ schema is structured Q&A pairs that enable FAQ rich results in Google search and provide AI search engines with highly citable structured content. The most-cited schema type by AI engines for product-related queries.

FAQPage schema structure

• FAQPage — root schema type (separate from Product, on same page)
• mainEntity — array of Question objects
• Question — each with name (the question) and acceptedAnswer
• Answer — with text containing the answer content

Example FAQ schema

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How long does the battery last?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The earbuds provide up to 8 hours of playback on a single charge. With the wireless charging case, total battery life extends to 30 hours."
      }
    },
    {
      "@type": "Question",
      "name": "Are they waterproof?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes, the earbuds are IPX5 rated for water resistance. They handle sweat and rain but should not be submerged."
      }
    }
    // 6-12 FAQs per product is typical
  ]
}
</script>

The visible content matching requirement

Google penalizes FAQ schema that doesn't match visible page FAQs. Common violation: implementing FAQ schema with questions/answers that don't actually appear on the page. The schema and visible content must match closely — same questions, same answers (paraphrasing acceptable, fundamentally different content not). Schema-only FAQs (not visible on page) violate the spirit of FAQ schema and trigger algorithmic penalties.

FAQ topics that drive AI citations

• Specifications: dimensions, weight, materials, technical specs
• Compatibility: what works with the product, what doesn't
• Use cases: what the product is for, who it's designed for
• Comparison: how it compares to alternatives in the category
• Care and maintenance: cleaning, storage, longevity
• Shipping and returns: delivery times, return process, warranty
• Common concerns: safety, allergens, durability, sizing

FAQ count recommendations

6-12 FAQs per product is the sweet spot. Below 6 misses citation opportunities; above 12 dilutes individual FAQ quality. Each FAQ should provide substantive answer (2-4 sentences typical). One-line answers offer less citation value than detailed substantive answers. Refresh FAQs quarterly based on customer service question patterns — the questions shoppers actually ask are higher-value than questions you guess they might ask.

The AI citation premium for FAQ content

AI search engines extract FAQ schema heavily for shopping queries. When a shopper asks ChatGPT "are these earbuds waterproof," the AI engine prefers extracting from FAQ schema (structured, attributable, citable) over guessing from product description. Brands with comprehensive FAQ schema get cited as authoritative sources for product-related questions, driving discovery traffic that bypasses traditional search.

Validation tools & common errors

Schema must be validated, not just implemented. Three validation tools work in complement — use all three because each catches different error categories.

Validation tool 1: Google Rich Results Test

URL: search.google.com/test/rich-results. Purpose: tests whether your schema qualifies for specific rich result types in Google Search. What it catches: Google-specific requirement violations, missing recommended properties for rich result eligibility, errors that block rich result display. What it misses: Schema.org spec violations that don't affect Google rich results. Use for: validating any product page before deployment.

Validation tool 2: Schema.org Validator

URL: validator.schema.org. Purpose: validates against the official Schema.org specification regardless of Google-specific requirements. What it catches: spec violations, invalid property types, incorrect nesting, deprecated properties. What it misses: Google-specific requirements beyond Schema.org spec. Use for: comprehensive schema correctness validation.

Validation tool 3: Google Search Console Rich Results Report

URL: Search Console → Enhancements → Rich Results. Purpose: shows aggregate schema health across your site and identifies pages with errors. What it catches: site-wide schema issues, patterns of errors across product pages, deprecation warnings. What it misses: page-specific debugging detail. Use for: ongoing monitoring, identifying broken pages, tracking schema-driven impressions and clicks.

The 5 most common schema errors

• Mismatched FAQ schema — FAQ schema content not matching visible page FAQs. Google penalizes; AI engines lose trust signal. Common when schema is auto-generated separately from page content
• Missing AggregateRating when reviews exist — products with reviews on the page but no AggregateRating schema. Lost star rating display in search results. Common when reviews app sync breaks
• Incorrect availability values — using custom strings like "Available" instead of required Schema.org URL values (https://schema.org/InStock). Schema appears to work but doesn't drive rich results
• Price without priceCurrency — or wrong currency code format. Common error for international brands using ambiguous "$" symbol instead of USD code
• Orphaned Review schema — Review schema without parent Product context. Often happens when Review schema is added separately from Product schema implementation

Validation workflow

1. Before deployment: Google Rich Results Test on the specific page being updated
2. After deployment: Schema.org Validator on the same page to catch spec violations Rich Results Test misses
3. Weekly: spot-check Search Console Rich Results Report for new errors emerging
4. Monthly: deep audit of Search Console aggregate data, identify patterns across product categories
5. Quarterly: comprehensive schema audit reviewing all 5 schema types across sample products from each category

AI search citation impact

The newer dimension of schema value: AI search engines cite products with complete schema markup more reliably than products without. As AI search captures more shopping discovery traffic through 2026, this citation eligibility becomes increasingly important.

How AI engines use schema

• ChatGPT shopping queries — evaluate product schema when generating responses. Products with complete schema get cited with higher confidence; products without get cited less or not at all even when otherwise relevant
• Perplexity citation logic — weights structured data heavily for citation sourcing. Schema-rich pages get cited as authoritative sources for product-related queries
• Alexa for Shopping (formerly Rufus) — treats product schema as primary citation source. Amazon listings with rich schema get prioritized in AI shopping recommendations
• Google AI Overviews / SGE — Google's AI search experiences use schema data directly. Brands with complete schema appear in AI summaries more frequently

The citation eligibility threshold

AI engines have implicit thresholds for citation eligibility. Products with sparse schema (minimal Product + basic Offer) often don't reach citation eligibility despite being relevant matches. Products with complete schema (all 5 types implemented well) consistently get cited. The threshold isn't documented but the pattern is clear from observed AI search behavior.

FAQ schema as AI citation goldmine

FAQ schema is the most-extracted schema type by AI engines for product queries. The structured Q&A format maps directly onto shopper questions, and AI engines extract FAQ answers with high confidence and proper citation. Brands with comprehensive FAQ schema get cited disproportionately often in AI shopping responses. Investment in FAQ schema delivers AI citation benefits beyond what traditional SEO measures would predict.

The compounding visibility effect

Strong schema doesn't just drive AI citations — it drives Google rich results, Google Shopping listings, and AI citations simultaneously. The same schema implementation enables three distinct visibility channels. Brands optimizing for one (traditional Google search) inadvertently optimize for all three. The investment-to-payback ratio is unusually favorable.

Measuring AI search impact

Measuring AI search traffic remains imperfect in 2026 because referrers from ChatGPT, Perplexity, and other AI engines are often opaque. Proxy metrics: rising direct traffic to specific product URLs, branded search increases (shoppers researching after AI recommendation), conversion lift on traffic that arrives with high purchase intent. Brands with strong schema typically see these signals strengthen as AI search adoption grows.

Platform-specific implementation

Implementation approach varies by ecommerce platform. Each major platform has different default schema coverage, customization paths, and common gaps. Understanding platform-specific patterns matters for efficient implementation.

Shopify implementation

Shopify themes include Product schema by default but coverage varies dramatically. Dawn theme (default): solid Product and Offer schema with most properties. Older themes: often incomplete schema, missing recent expansions (ShippingDetails, hasMerchantReturnPolicy). Custom Shopify themes: schema quality depends entirely on the developer who built it. Reviews apps: Judge.me, Yotpo, Okendo, Stamped, Junip typically inject AggregateRating and Review schema automatically. SEO apps: Yoast, Schema Pro for Shopify, JSON-LD for SEO handle additional schema types. Headless Shopify: schema must be built manually in the templating layer (Next.js, Gatsby, etc.). Validate platform-default schema rather than assuming it's complete.

WooCommerce implementation

WooCommerce includes basic Product schema by default. Yoast WooCommerce SEO adds comprehensive schema enhancements including Product, Offer, AggregateRating, Review, and FAQ schema. Rank Math Pro provides similar schema coverage with potentially deeper customization. Schema Pro (separate plugin) handles advanced schema scenarios. For most WooCommerce stores, Yoast Premium or Rank Math Pro plus a reviews plugin provides complete coverage. Validate schema after every plugin update — updates occasionally introduce regressions.

BigCommerce implementation

BigCommerce includes Product schema by default. The Stencil framework supports schema customization through theme files. Less aggressive default coverage than Shopify Dawn but more flexibility for custom implementation. Reviews plugins (BigCommerce native reviews, Yotpo, Stamped) inject rating/review schema. SEO apps handle FAQ and additional schema types. BigCommerce's headless framework Catalyst gives full schema control but requires manual implementation.

Magento (Adobe Commerce) implementation

Magento 2 includes Product schema with reasonable defaults. Schema enhancements typically come through extensions: Mageworx Schema Pro, Mirasvit Advanced SEO, Amasty SEO Toolkit. Enterprise Magento implementations often include custom schema logic for B2B scenarios, multi-store schema variations, and complex pricing scenarios (tiered pricing, customer-group pricing). Validate schema in admin preview before customer-facing deployment — Magento's complexity creates more potential schema regression points than simpler platforms.

Headless ecommerce implementation

Headless implementations (Next.js, Gatsby, custom frameworks) require manual schema implementation in the templating layer. Pattern: pull product data from ecommerce API (Shopify Storefront API, BigCommerce API, etc.), inject into Next.js getServerSideProps or Gatsby template, serialize as JSON-LD in the page head. The advantage: complete control over schema accuracy and completeness. The disadvantage: more development overhead than platform-default schema. Most growing headless brands eventually implement structured schema generation libraries to avoid repetitive code.

The platform validation reality

Regardless of platform, validate the actual rendered schema on production pages rather than trusting platform documentation. Themes update, plugins change, custom code accumulates — the real schema on real pages often differs from documented expectations. Periodic validation across sample products from each category catches drift before it materially affects search performance.

How Evolve Media structures schema programs

Schema markup audits, implementation, and ongoing maintenance are part of EMA's broader technical SEO and AI search optimization work for ecom brands. Most brands have schema implementations that look adequate but contain silent errors defeating intended benefits.

The 30-day schema implementation program

Schema audit across all product page templates using all three validation tools. Gap analysis identifying missing schema types, incomplete properties, and validation errors. Complete 5-type schema implementation (Product, Offer, AggregateRating, Review, FAQ) with platform-appropriate approach. Validation testing across sample products from each category. Ongoing maintenance setup including quarterly audit cadence and update workflows.

Ongoing schema operations

For brands maintaining schema implementations, EMA handles monthly Search Console Rich Results monitoring, quarterly comprehensive schema audits, schema updates as Google introduces new properties (e.g., 2022 ShippingDetails, 2023 hasMerchantReturnPolicy, ongoing schema evolution), and integration coordination with theme updates, plugin changes, and platform migrations that could affect schema.

Integration with broader strategy

Schema markup integrates with AI search optimization (the citation eligibility layer), reviews app selection (which platforms inject AggregateRating/Review schema), Google Performance Max (Shopping ad eligibility depends on schema), and AI visibility auditing (the broader visibility framework where schema sits).