How To Create Product Schema

Even after achieving high search engine rankings, there’s no guarantee people will click your links. Of course, you don’t want your efforts to go to waste. That’s why product schema is so powerful: It enables search engines to show links with extra information. On average, these rich snippets are much more appealing to searchers and can drive additional clicks.

Implementing structured data can be a bit tricky, though, so I’ve prepared this handy step-by-step guide, which includes product schema markup examples, to demonstrate how it all comes together.

What Is Product Schema?

Product schema is a form of schema markup — information formatted specifically for computers. It enables search engines to find details about your products, such as:

• Pricing.
• Reviews and ratings.
• Special offers.
• Awards.

Depending on the type of product, there are even more properties you can make use of to easily share information with search crawlers.

For example, you can list clothing sizes, materials, and colors or electronics’ operating systems and storage capacity details.

When Google links to products in search results, it may include some of this data. The result is rich snippets that stand out with product pictures and valuable information at a glance. Just like how a featured snippet improves the visibility of informational content, these rich product links attract much more attention.

Product schema declares a single SKU as its own distinct entity, separate from the category or collection page it sits under. Product schema helps a system parsing your catalog tell one product from another so it doesn’t fold every variant into the same category concept.

Why Product Schema Is Critical for Ecommerce Sites

After glancing at a few product schema markup examples, it’s easy to understand why it’s one of the most important schema types for ecommerce sites. Rich snippets are simply more noticeable and compelling. They instantly provide information shoppers want, like price, reviews, and even shipping info. If you don’t use them, you risk losing search visibility to competitors.

Product schema gives you:

• Higher visibility and ROI. Rich snippets generate higher click-through rates (CTRs) because they’re more visible. However, the additional information also helps filter out unqualified leads. As a result, your traffic converts more readily, boosting returns.
• Better search rankings. One aspect of rankability is the ease with which search engines understand your content. Product schema helps Google evaluate your content and determine its relevance, bringing you long-term ranking gains, which means more customers over time.
• Improved user experience. Customers appreciate upfront information when making purchases. Schema even lets you include shipping information and discounts. This results in higher user experience (UX) satisfaction and reduced cart abandonment, as customers know what they’re getting and don’t need to waste time confirming shipping details or prices.

Even if your competitors use product schema, implementing it doesn’t merely equalize the playing field. Many businesses don’t fully benefit from schema because they don’t optimize it. Often, they don’t update their data frequently enough or only include basic details, so tactful use of markup still grants you a considerable advantage.

How To Create Product Schema

Now that you understand the benefits structured data brings to your products, you’re probably wondering how to create product schema. Here’s a step-by-step rundown.

1. Choose Your Schema Format

Schema data can technically be implemented three ways: JSON-LD, Microdata, or RDFa.

Victorious implements JSON-LD exclusively, and every example in this guide uses it. JSON-LD (JavaScript Object Notation for Linked Data) is a script placed in the head of your product page’s HTML, which keeps all your structured data in one place and makes it far easier to audit, update, or hand off to a developer later.

Microdata and RDFa insert schema details directly into inline HTML tags scattered across the page instead. Both still work, and you’ll encounter them elsewhere, but neither offers a good reason to choose it over JSON-LD today.G

Google recommends JSON-LD and most schema plugins generate JSON-LD. And keeping your markup in one script block instead of interleaved through your HTML is simply easier to maintain at scale. You don’t have to go back through the HTML with a fine-tooth comb every time you want to adjust it, and tools and plugins typically use this implementation too, making.

2. Identify Product Attributes

You can reference many product attributes using schema. Google treats some as required and others as recommended depending on what you want the listing to do. The table below reconciles both. It lists everything you need for a basic rich result, and everything you need for a full merchant listing that shows price and availability directly in search.

Google’s basic Product rich result needs only the name property plus one of review, aggregateRating, or offers. The full Required list above unlocks an actual merchant listing, showing price and availability right in the search result, which is the version most ecommerce sites are really after.

Two properties in the table are easy to add and easy to get wrong. priceValidUntil tells Google when to stop trusting a listed price, so a stale date can quietly pull your rich result even though nothing else about the page changed. itemCondition tells Google whether you’re selling something new, refurbished, or used, which shoppers filter on directly. Both show up in the laptop example below.

One more thing before you add review or aggregateRating markup: Google’s review-snippet guidelines, updated July 24, 2026, explicitly prohibit fake or undisclosed incentivized reviews in either your visible content or your structured data, and any review content you mark up has to be readable by a visitor on that same page. If you incentivize reviews with discounts or free products, disclose it clearly, or leave the incentivized ones out of your markup entirely.

If you sell the same product in multiple sizes, colors, or configurations, isVariantOf ties each variant back to a shared product group instead of listing them as unrelated items. The T-shirt example later in this guide uses simple size and color arrays on a single product, which works for a small catalog, but a full variant setup using isVariantOf is worth the extra structure once you’re managing dozens of SKUs per style.

AggregateOffer describes a price range across multiple sellers, and Google’s merchant listing documentation states that product snippets accept an Offer or an AggregateOffer, but merchant listings require an Offer. If you sell the product directly, putting AggregateOffer on that page disqualifies it from the merchant listing you’re working toward. Keep a single Offer entry carrying one specific price.

Take a look at the Product Schema documentation for specific attributes you can use to leverage schema more effectively than competitors.

3. Add Shipping Details Schema

Google expanded how merchants share shipping and return-policy data in a November 2025 announcement, adding organization-level markup and a Search Console setting. 

At the product level, shippingDetails is the property that carries the shipping half. Google’s own guidance still lists it as recommended, not strictly required, for a basic listing, but it unlocks the shipping-cost and delivery-estimate information shoppers see directly in the search result, and it’s covered in every competing guide on this topic. Shipping cost is one of the first things a shopper checks, so there’s a real gap between “eligible for a rich result” and “showing the information that gets someone to click.”

Nest an OfferShippingDetails object inside your existing offers property, alongside the price fields already there. At minimum, that means a shipping rate and a destination:

“offers”: {
  “@type”: “Offer”,
  “price”: “24.99”,
  “priceCurrency”: “USD”,
  “availability”: “https://schema.org/InStock”,
  “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”: 2,
        “maxValue”: 5,
        “unitCode”: “DAY”
      }
    }
  }
}

That example shows free shipping to the US with next-day handling and a two-to-five-day transit window. If you ship to multiple regions at different rates, or exclude certain regions entirely, add a separate shippingDetails entry for each combination. Don’t average them into one. See Google’s shipping structured data documentation for the full property list, including how to mark regions you don’t ship to at all.

4. Add Merchant Return Policy Schema

Return policy schema, hasMerchantReturnPolicy, pairs directly with shipping details in Google’s guidance, and it answers the question that usually follows “how much is shipping.” What happens if the item needs to go back? Nest a MerchantReturnPolicy object inside your offers property alongside shippingDetails:

“hasMerchantReturnPolicy”: {
  “@type”: “MerchantReturnPolicy”,
  “applicableCountry”: [
    “US”
  ],
  “returnPolicyCategory”: “https://schema.org/MerchantReturnFiniteReturnWindow”,
  “merchantReturnDays”: 30,
  “returnMethod”: “https://schema.org/ReturnByMail”,
  “returnFees”: “https://schema.org/FreeReturn”
}

Google requires applicableCountry and returnPolicyCategory together, and merchantReturnDays becomes required once returnPolicyCategory is set to a finite return window. Everything else above is recommended. 

Google also recommends setting shipping and return policy at the organization level, covering your whole catalog, instead of repeating identical policy data on every product. Use the per-offer version shown here only to override that default for a specific product, or when you don’t have a standard, sitewide policy. Full property details are in Google’s return policy structured data documentation.

5. Insert Data Into Your HTML

To enter schema into a page, start by assigning a script with the type “application/ld+json” in the document’s head section. The next lines of JavaScript identify the script as product schema and provide all the information you’d like to assign as markup. This is how it will look:

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org/”,
  “@type”: “Product”,
  “name”: “Example Product”,
  “image”: “https://example.com/photos/1×1/photo.jpg”,
  “description”: “Example product description.”,
  “sku”: “12345”
}
</script>

Everything else goes inside the same braces, before the closing script tag. If you want to add ratings, reviews, and offers, the full examples ahead show how to enter them.

The shipping and return-policy properties from steps 3 and 4 nest into this same script, inside the offers object. You’re adding more properties to the same script tag, not a second one.

6. Validate the Schema

Validating schema just means checking to ensure it works correctly and contains no errors. The best way is to use Google Search Console’s structured data checker, either through the URL inspect tool or the Rich Results Test. This is because Search Console will specifically tell you whether the markup is correct and whether it has everything necessary for a rich snippet in Google. Search Console also routinely flags any structured data issues it finds on existing pages.

Alternatively, check URLs or code on schema.org or use another third-party validator. Many site audit tools also validate schema periodically.

If validation turns up warnings instead of a clean pass, the next step covers the ones that show up most often.

7. Fix Common Validation Errors

A handful of errors account for most Product schema validation failures:

• Review markup that doesn’t match what’s visible on the page. Google requires that any review content you mark up also be readable by a visitor on that same page. Schema-only reviews the reader can’t see are a policy violation, not just a formatting one.
• Missing required fields. If name, image, offers, price, or priceCurrency is missing or empty, Google won’t treat the page as eligible for a merchant listing at all. This is the most common error, usually because a template pulls price from a field that’s blank for out-of-stock items.
• Product schema on a category or listing page. Google’s guidance is explicit that Product structured data is for a page about one specific product, or variants of that one product, not a page listing multiple different products, like a category page. “Shoes in our shop” is not a specific product. Use ItemList schema instead on listing pages.
• A priceValidUntil date in the past. Google’s documentation states plainly that your listing may stop showing once this date has passed. It’s an easy field to set once and forget, especially on evergreen product pages that don’t run sales.
• Currency or price mismatches. priceCurrency needs a valid three-letter ISO 4217 code, and price needs to match what a shopper would be charged. A page showing “$49.99” with priceCurrency set to “EUR” still passes the validator, because EUR is a legitimate code, so the mismatch clears every automated check and then misleads both shoppers and the systems reading your markup. Check this one by eye against the visible price.

Product Schema Markup Examples

Schema markup assigns properties that contain information associated with specific products. Take a look at the following product schema markup examples, and you’ll see how you might use custom properties to your advantage with the additional property parameter. Our first example also demonstrates how to implement the rating and offers markups.

Laptop Example:

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org/”,
  “@type”: “Product”,
  “name”: “XYZ Gaming Laptop”,
  “image”: “https://example.com/photos/laptop.jpg”,
  “description”: “A high-performance laptop for gaming and professional use, with 32GB of RAM and a 2TB SSD.”,
  “sku”: “LAP12345”,
  “brand”: {
    “@type”: “Brand”,
    “name”: “TechBrand”
  },
  “model”: “XYZ123”,
  “releaseDate”: “2024-01-15”,
  “additionalProperty”: [
    {
      “@type”: “PropertyValue”,
      “name”: “Operating System”,
      “value”: “Windows 11”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Processor”,
      “value”: “Intel Core i9”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Memory”,
      “value”: “32GB RAM”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Storage Capacity”,
      “value”: “2TB SSD”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Battery Life”,
      “value”: “10 hours”
    }
  ],
  “offers”: {
    “@type”: “Offer”,
    “url”: “https://example.com/product/laptop”,
    “priceCurrency”: “USD”,
    “price”: “2499.99”,
    “priceValidUntil”: “2027-12-31”,
    “itemCondition”: “https://schema.org/NewCondition”,
    “availability”: “https://schema.org/InStock”
  },
  “aggregateRating”: {
    “@type”: “AggregateRating”,
    “ratingValue”: “4.7”,
    “reviewCount”: “87”
  }
}
</script>

Men’s T-Shirt Example:

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org/”,
  “@type”: “Product”,
  “name”: “Men’s Casual T-Shirt”,
  “image”: “https://example.com/photos/tshirt.jpg”,
  “description”: “A comfortable t-shirt for men, made from 100% cotton.”,
  “sku”: “TSHIRT12345”,
  “brand”: {
    “@type”: “Brand”,
    “name”: “FashionBrand”
  },
  “size”: [
    “Small”,
    “Medium”,
    “Large”,
    “XL”
  ],
  “color”: [
    “Red”,
    “Blue”,
    “Black”
  ],
  “material”: “100% Cotton”,
  “pattern”: “Solid”,
  “additionalProperty”: [
    {
      “@type”: “PropertyValue”,
      “name”: “Gender”,
      “value”: “Male”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Age Group”,
      “value”: “Adult”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Fit”,
      “value”: “Regular Fit”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Care Instructions”,
      “value”: “Machine Washable”
    },
    {
      “@type”: “PropertyValue”,
      “name”: “Occasion”,
      “value”: “Casual”
    }
  ],
  “offers”: {
    “@type”: “Offer”,
    “url”: “https://example.com/product/tshirt”,
    “priceCurrency”: “USD”,
    “price”: “24.99”,
    “priceValidUntil”: “2027-12-31”,
    “itemCondition”: “https://schema.org/NewCondition”,
    “availability”: “https://schema.org/InStock”
  }
}
</script>

Board Game Example:

<script type=”application/ld+json”>
{
  “@context”: “https://schema.org/”,
  “@type”: “Product”,
  “name”: “Example Board Game”,
  “image”: “https://example.com/photos/boardgame.jpg”,
  “description”: “An exciting board game for 2-6 players.”,
  “sku”: “BG12345”,
  “brand”: {
    “@type”: “Brand”,
    “name”: “GameBrand”
  },
  “material”: “Cardboard, Plastic”,
  “additionalProperty”: [
    {
      “@type”: “PropertyValue”,
      “name”: “Number of Players”,
      “value”: “2-6”
    }
  ],
  “offers”: {
    “@type”: “Offer”,
    “url”: “https://example.com/product/boardgame”,
    “priceCurrency”: “USD”,
    “price”: “39.99”,
    “priceValidUntil”: “2027-12-31”,
    “itemCondition”: “https://schema.org/NewCondition”,
    “availability”: “https://schema.org/InStock”
  }
}
</script>

Useful Product Schema Tools

Entering schema markup manually is ok for small inventories. However, doing things at scale can take a lot of time, so it’s best to use tools to automate the process. Here are some excellent options:

• Google’s Structured Data Markup Helper: The Structured Data Markup Helper displays chosen URLs, allowing you to tag product details such as name, description, or price and generate schema markup from it, speeding up implementation. Google hasn’t meaningfully updated this tool in some time, and it’s increasingly dated next to newer, actively maintained options. It still works, but don’t expect it to cover newer properties like shippingDetails or hasMerchantReturnPolicy.
• Schema.dev’s Structured Data Tool Set: Schema.dev offers a full suite of tools that let you generate schema, test it, and deploy it to your website automatically.
• Schema WordPress Plugin: The Schema WordPress Plugin automates markup by pulling metadata from the page. While this is powerful, you can take things a step further with the WooCommerce add-on, which draws upon product information from your WooCommerce database. When you adjust pricing and other details in the database, you can then update the schema on many pages at once.

Overall, plugins offer the best solution for ecommerce sites with large inventories. Markup plugins often also handle several schema types in addition to products. This way, you’re covered if you plan to target position zero SERP features through a blog on the same site. Structured data also improves overall site accessibility.

Stand Out in the SERPs With a Trusted Partner

Shine a spotlight on your products with structured data and rich snippets. While schema helps your business maximize its returns, implementing it takes time, regardless of the size of your site. Need a hand? Contact us for a free SEO consultation, and our ecommerce agency will handle the planning and execution, freeing you up to focus on your customers and vision.

Product Schema FAQ