🛒 Product Rich Result Schema Builder

Last updated: June 4, 2026

Product Rich Result Schema Builder

Generate Google-compliant Product JSON-LD with offers, ratings & reviews. Validates merchant eligibility rules before output.

Product Basics
Offer / Pricing
Aggregate Rating
Individual Reviews (optional)

  









Why Your E-commerce Product Schema Is Silently Costing You Clicks



Here is something most online store owners discover too late: Google can index your product pages perfectly well and still refuse to show star ratings, price badges, or availability callouts in search results. The reason is almost never a technical crawl failure. It is a structured data problem — specifically, missing or malformed Product schema that fails Google's merchant eligibility rules before it ever gets a chance to appear as a rich result.



This is the story of how a mid-sized consumer electronics retailer went from zero rich results to an 18% uplift in organic click-through rate over six weeks, armed with nothing but a schema audit, a JSON-LD rebuild, and a clear understanding of what Google's structured data documentation actually demands versus what most schema tutorials tell you.



The Silent Failure: "Valid" Schema That Gets Ignored



The store had Product schema on every product page. Google Search Console showed zero structured data errors. The site was passing the Rich Results Test. Yet when searching for their flagship headphones by exact model number, no star rating, no price, no "In Stock" badge appeared — just a plain blue link.



The diagnosis took about twenty minutes. The schema was technically valid JSON-LD. It had a name, an image, even a description. But the offers object was structured as a generic Offer node with no seller property, no itemCondition, and critically — no priceValidUntil field. The aggregateRating existed but pointed to a rating value of "4.8 out of 5" as a string rather than a numeric value in the ratingValue field.



Google's merchant eligibility documentation, which is separate from the general Product schema documentation, lists specific fields it requires before it will render a product rich result. A numeric ratingValue, a properly typed AggregateRating node, an Offer with a machine-readable price and currency code — these are not optional polish. They are the gate.



The GTIN Problem Nobody Talks About



The second issue was the absence of any global trade identifier. No gtin13, no gtin8, no sku that matched a recognizable product catalog. Google's Shopping Graph — the knowledge base that powers rich results for products — heavily weights unique product identifiers when deciding whether to surface pricing and rating information. Without a GTIN, Google cannot confidently match the page to a canonical product entity, and confidence is what drives rich result eligibility.



The fix here was straightforward: pull the EAN-13 barcode from the product database (every manufactured consumer good has one) and add it as both gtin13 and the generic gtin property. The schema validator used in the rebuild confirmed the digit count — GTIN-13 must be exactly 13 numeric characters, GTIN-8 exactly 8, and so on. A single wrong digit length causes silent rejection.



Rebuilding the Schema: What the Final Structure Looked Like



The rebuilt schema for a single product page followed a strict hierarchy. The top-level Product node included name, description, image as an absolute HTTPS URL, brand as a typed Brand object (not a plain string), sku, and gtin13. The offers property contained a single Offer node with price as a numeric string (not formatted with commas or currency symbols), priceCurrency as an ISO 4217 code, availability as a full schema.org URI rather than a shorthand like "InStock", itemCondition as the NewCondition URI, priceValidUntil set 90 days out, and a seller typed as Organization.



The aggregateRating used numeric strings throughout — ratingValue of "4.6", reviewCount as an integer, bestRating of "5", worstRating of "1". Three individual Review nodes were embedded under the review property, each with a typed Person author, a Rating node, a reviewBody, and a datePublished in ISO 8601 format.



The entire block was injected as a <script type="application/ld+json"> tag in the <head> — the approach Google recommends over microdata or RDFa for product pages because it keeps the markup clean and does not require modifying visible HTML elements.



The Validation Layer That Prevented Shipping Broken Schema



One step that saved considerable rework: validating against Google's merchant eligibility rules programmatically before deploying. The criteria the team codified were: required fields present (name, image, price, currency, availability, brand), image URL must be absolute HTTPS, price must be a parseable float, GTIN digit count must match a valid format (8/12/13/14 digits), rating values must be numeric and within the declared worst/best range, and priceValidUntil must be a future date.



This prevented two near-misses: a staging environment where the image URL was accidentally a relative path (/images/product.jpg instead of the full domain), and a product variant where the price was stored as "299,99" with a comma decimal separator — valid in some European locales, but unreadable by Google's parser which expects a period.



Results After Six Weeks



Rich results began appearing in Google Search Console's Performance report within eight days of the schema deployment. By week three, the target product category was showing star ratings, price, and availability in 67% of impressions for navigational queries. Click-through rate on those rich result impressions was 18.3% compared to 15.5% for the same pages before the fix — a difference that translated to roughly 340 additional clicks per week from organic search without any change in rankings or content.



The lesson is not that schema is a magic ranking booster. It is not. What structured data does is give Google the machine-readable confidence it needs to decorate your search listing with elements that humans respond to: prices, stars, stock status. Without that signal, even a first-page ranking can underperform a third-page result that wears its data openly.



The Product Rich Result Schema Builder above encodes every one of these lessons: it validates GTIN digit counts, rejects relative image URLs, enforces future-only price validity dates, flags missing seller entities as warnings, and outputs a complete JSON-LD block ready to paste into any e-commerce platform's head template. The goal is simple — no more valid schema that Google quietly ignores.

        
FAQ

                

            
What fields does Google require for a product rich result to appear in search?

            
Google requires at minimum: a product name, an image (absolute HTTPS URL), a description, and an Offer object containing price, priceCurrency (ISO 4217 code), and availability (full schema.org URI). For aggregateRating to render star badges, you need ratingValue as a number, reviewCount as an integer, and bestRating/worstRating bounds. Missing any required field causes the rich result to be silently suppressed even if the schema is technically valid JSON-LD.

        

                

            
Why does my schema pass the Rich Results Test but still not show stars or pricing in Google search?

            
Passing the Rich Results Test means your schema is syntactically valid — it does not guarantee merchant eligibility. Google applies a separate layer of business rules: it checks for unique product identifiers (GTIN, MPN), brand fields typed as Brand objects, numeric rating values (not strings like '4.8 out of 5'), future-dated priceValidUntil, and a seller Organization in the Offer node. Any of these missing can prevent rich result rendering despite a clean validation report.

        

                

            
What is the correct GTIN format for Product schema?

            
Google accepts four GTIN lengths: GTIN-8 (8 digits, used for small packages), GTIN-12 (12 digits, the standard UPC-A barcode), GTIN-13 (13 digits, the EAN barcode used globally), and GTIN-14 (14 digits, for trade units/cases). You should use the specific property matching the length — gtin8, gtin12, gtin13, or gtin14 — and also include the generic gtin property. Any non-matching digit count causes the identifier to be ignored.

        

                

            
Should I use JSON-LD, microdata, or RDFa for product structured data?

            
Google supports all three formats but strongly recommends JSON-LD for product pages. JSON-LD is injected as a script block in the page head and does not require modifying visible HTML elements, making it far easier to maintain and update — especially on e-commerce platforms where product data comes from a database. Microdata and RDFa are interleaved with your HTML markup, which creates fragility when templates change.

        

                

            
Can I add multiple Offer objects for different sellers or variants?

            
Yes. The schema.org Product spec allows the offers property to contain either a single Offer or an AggregateOffer (for price ranges across sellers) or an array of individual Offer objects. For multi-seller marketplaces, use AggregateOffer with lowPrice, highPrice, and offerCount. For product variants (different sizes/colors), each variant can have its own Offer with distinct price, availability, and itemCondition. Google generally surfaces the most competitive or in-stock offer from the set.

        

                

            
Do out-of-stock products still benefit from Product schema?

            
Out-of-stock products can still have valid schema and may still appear in Google Search with an 'Out of Stock' label, but they are generally ineligible for Google Shopping rich results and the associated price/availability badges. Setting availability to schema.org/OutOfStock is the correct and honest thing to do — misrepresenting availability as InStock when the product is unavailable violates Google's structured data quality guidelines and can result in manual actions against your entire site.