Shopify App Store

What are You Looking for?

Shopify rich snippets for combined listings: complete schema guide (2026)

Rich snippets are the extras that turn a plain Google blue link into a result with stars, a price, “in stock,” shipping info, and sometimes a thumbnail. They typically lift click-through-rate by 20 to 30% over plain results. For Shopify product pages they are mostly automatic, but combined listings introduce a wrinkle: each color or size variant should earn its own rich snippet, and the parent group should ideally be recognized as a ProductGroup. Set this up wrong and you either lose the snippets entirely or Google starts ignoring whichever schema looks duplicated.

This is the working guide for getting rich snippets on combined listings: the schema types you actually want, the difference between Product and ProductGroup, what Shopify generates by default, what your theme might be missing, how to test, and how AI agents read the same data. We use real schema.org definitions and Google Rich Results spec where the docs say something specific.

If you have already read our deeper post on the duplicate schema trap, this guide is the broader companion: less about avoiding mistakes, more about getting the full setup right. Both work together.

In this post

What rich snippets are and what you actually get

A rich snippet is the enhanced search result Google shows when a page contains valid structured data. For ecommerce products, the rich snippet can include any combination of:

  • Star rating and number of reviews
  • Price (or price range)
  • Availability (“In stock”, “Out of stock”, “Pre-order”)
  • Shipping cost and delivery estimate
  • Product image thumbnail
  • Sale price and original price (with a strike-through)
  • Returns policy summary

None of this is guaranteed. Google chooses which elements to show based on the schema present, the page’s authority, and the search query context. Two pages with identical schema can render different rich snippets. The point is that having the schema makes you eligible; missing or invalid schema makes you ineligible.

Product vs ProductGroup schema (and why both matter for combined listings)

Schema.org defines two relevant types:

  • Product: an individual sellable product. Has price, image, SKU, availability, ratings.
  • ProductGroup: a group of products that “vary only in certain well-described ways, such as by size, color, material.” A ProductGroup is not directly offered for sale; the variants linked to it are.

For a combined listing where you sell the same hoodie in 5 colors as 5 separate products linked together, the ideal setup is:

  • Each color page renders Product schema describing that specific color.
  • Each Product declares isVariantOf pointing to a ProductGroup with a shared productGroupID.
  • The ProductGroup can also be on the parent listing page (when one exists), declaring hasVariant for each color and variesBy: ["color"].

Why this structure? Because Google can then understand “these 5 products are the same hoodie in different colors” and surface the right rich snippet for the right query. A search for “navy hoodie” returns the navy color page with its specific price and rating; a generic search for “the brand hoodie” can surface either the parent or the most popular variant, with Google’s algorithm choosing based on context.

Without ProductGroup linking, Google sees the 5 color pages as 5 independent products that happen to share a brand. SEO authority does not flow between them, and rich snippets show up inconsistently.

What Shopify ships by default

Most modern Shopify themes (Dawn, Horizon, Prestige, Stiletto) ship with basic Product JSON-LD on product pages. The default schema typically includes:

  • Product name
  • Description
  • Image (cover image)
  • SKU (if set)
  • Brand (vendor)
  • Offers (price + availability + URL + currency)

What Shopify themes typically do not ship by default:

  • AggregateRating. Reviews come from third-party apps (Judge.me, Loox, Stamped). Apps usually inject their own AggregateRating block separately. If your reviews app does not, you lose star ratings in rich snippets.
  • ProductGroup linkage. Default themes treat each product as standalone. If your products are part of a combined listing, the schema does not declare it.
  • AggregateOffer for variant price ranges. If a product has variants at different prices, the default Offers block typically shows one variant’s price, not the range.

To check what your theme actually ships: open a product page in your live store, view source (Ctrl+U or Cmd+U), search for application/ld+json. Read the JSON. That is exactly what Google sees.

The minimum Product schema for a rich snippet

Google’s minimum required fields for a Product rich result are name plus at least one of:

  • review or aggregateRating
  • offers

Recommended (Google strongly suggests for richer results): image, description, brand, sku, gtin or mpn, availability, price, priceCurrency.

A working minimum block looks like this:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Oversized Hoodie - Navy",
  "image": "https://yourdomain.com/image.jpg",
  "description": "Heavyweight cotton hoodie in deep navy",
  "brand": { "@type": "Brand", "name": "Your Brand" },
  "sku": "HOODIE-NAVY-M",
  "offers": {
    "@type": "Offer",
    "url": "https://yourdomain.com/products/oversized-hoodie-navy",
    "priceCurrency": "USD",
    "price": "79.00",
    "availability": "https://schema.org/InStock"
  }
}

Most Shopify themes generate something close to this automatically using Liquid. Verify yours in view-source.

Adding ProductGroup schema for the combined listing

To declare that this product is part of a combined listing group, add an isVariantOf field pointing to a ProductGroup. The ProductGroup itself is a separate schema object, often defined inline:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Oversized Hoodie - Navy",
  "sku": "HOODIE-NAVY-M",
  "isVariantOf": {
    "@type": "ProductGroup",
    "@id": "https://yourdomain.com/products/oversized-hoodie#group",
    "name": "Oversized Hoodie",
    "productGroupID": "OVERSIZED-HOODIE",
    "variesBy": ["color"]
  },
  "color": "Navy",
  "offers": { /* ... */ }
}

Each color page (each “child” Product in the combined listing) declares the same productGroupID, so Google can connect them.

Adding ProductGroup schema typically requires either:

  • A theme edit to add the isVariantOf block to your main-product.liquid JSON-LD generation. Knowledge of Liquid required.
  • An app that injects ProductGroup schema. Some combined listings apps inject this automatically; some schema-only apps add it on top of any existing setup.
  • A SEO/schema-focused app that handles the structured data layer broadly.

Rubik Combined Listings uses metaobject references to define groups, which means the ProductGroup relationship is encoded structurally even when not explicitly rendered in JSON-LD. For maximum rich snippet eligibility, add ProductGroup JSON-LD via your theme or a schema app on top.

Offer, AggregateOffer, and AggregateRating

Three schemas that affect what shows in a rich snippet:

Offer (single price)

"offers": {
  "@type": "Offer",
  "price": "79.00",
  "priceCurrency": "USD",
  "availability": "https://schema.org/InStock",
  "url": "https://yourdomain.com/products/hoodie-navy"
}

Use for a product with a single price. Renders as the price on the rich snippet.

AggregateOffer (price range)

"offers": {
  "@type": "AggregateOffer",
  "lowPrice": "59.00",
  "highPrice": "89.00",
  "priceCurrency": "USD",
  "offerCount": 12,
  "availability": "https://schema.org/InStock"
}

Use for products with multiple variants at different prices. Google renders as a price range like “$59 to $89” in the rich snippet.

AggregateRating

"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": "4.8",
  "reviewCount": 234
}

Source from your reviews app. Renders as star rating in rich snippet. Most popular review apps (Judge.me, Loox, Stamped, Yotpo) inject this automatically. If yours does not, switch to one that does.

Testing with Google Rich Results Test

Validate every product page change with Google’s free Rich Results Test:

  1. Go to search.google.com/test/rich-results.
  2. Paste your product page URL.
  3. Click Test URL.
  4. Read the report. Confirm “Eligible for Product results” appears.
  5. Check the “Issues” section. Address any errors (red) and warnings (yellow).

Common issues the test surfaces:

  • Missing image: image URL is invalid or returns 404.
  • Missing offers: price is not declared or availability is missing.
  • Two Product blocks: theme schema plus app schema, both describing the same page. Google rejects ambiguity. Pick one source of schema and disable the other.
  • Invalid availability value: must be a schema.org URL like https://schema.org/InStock, not a free string.

Re-run the test after every theme change, every app install that touches schema, and every Shopify version update.

Common issues that block rich snippets

  • Two Product schema blocks on the same page. Theme renders one, an app renders another. Google sees ambiguity and may ignore both. Audit your view-source; pick one source.
  • Schema points to wrong URL. The offers.url or @id field references a different page than the page rendering the schema. Self-referential URLs only.
  • AggregateRating without actual reviews. Google distrusts schema that claims a rating but the page has no visible reviews. Make sure reviews are actually rendered on the page, not just claimed in schema.
  • Wrong availability values. “Yes” or “No” do not work; use https://schema.org/InStock or https://schema.org/OutOfStock exactly.
  • Page is noindex. Schema cannot help a page Google is told not to index. Check the meta robots tag.
  • Page is too new. Even with valid schema, rich snippets typically appear 1 to 4 weeks after Google reindexes the page. Submit URL Inspection in Search Console to accelerate.
  • Authority too low. Google sometimes withholds rich snippets for new or low-authority pages. Building general SEO authority (links, brand searches, dwell time) eventually unlocks them.

How AI agents use the same schema

Rich snippets are a Google-specific surface. AI agents (ChatGPT, Perplexity, Copilot, Google AI Mode) use much of the same structured data, but for different purposes:

  • Product entity matching. Schema fields like name, brand, color, and productGroupID help AI agents match the right product to a user query.
  • Citation confidence. Pages with valid, complete schema get cited more often than pages with missing or broken schema, because AI agents grade source quality partly on structured data signals.
  • Variant relationships. ProductGroup schema explicitly tells AI agents “these products are siblings, not strangers,” which improves how the agent surfaces your catalog when a shopper asks about a specific color or size variation.

So the same schema work pays off twice: better rich snippets in Google plus better surfacing in AI agent responses. We covered the agent-specific implications more deeply in how variant grouping affects AI shopping discovery.

Third-party combined listings apps and schema

Different combined listings apps handle schema differently. Three approaches you might encounter:

  • App injects a second Product block describing the group. Causes the duplicate schema problem (Google sees two Product blocks; rejects both). We have a deeper post on this duplicate schema trap.
  • App leaves theme schema alone, adds nothing. Schema is correct for individual products but does not declare the ProductGroup relationship. SEO works; ProductGroup signal is missing.
  • App adds isVariantOf linkage to the existing theme schema. Cleanest approach, requires deeper integration than most apps build.

For Rubik Combined Listings specifically, the app uses metaobject references to define the group structurally without injecting duplicate Product schema. To get explicit ProductGroup JSON-LD on top, you can either:

  • Add ProductGroup schema via theme Liquid (point each child product’s isVariantOf at the parent’s productGroupID).
  • Use a schema-focused app like JSON-LD Schema apps, ensuring it is configured to read your group structure correctly.

For most Shopify stores, the default Product schema plus a clean reviews app is enough to earn rich snippets without the ProductGroup layer. Add ProductGroup when you want maximum AI agent surfacing of your catalog as connected groups, not just for Google rich results.

Try Rubik Combined Listings free
Try Rubik Variant Images free

Frequently asked questions

Does Shopify automatically add Product schema to my product pages?

Most modern Shopify themes (Dawn, Horizon, Prestige, Stiletto, and similar) include basic Product JSON-LD by default, with name, description, image, brand, SKU, and offers. AggregateRating typically comes from your reviews app. ProductGroup linkage for combined listings is not standard and requires a theme edit or schema app.

What is the difference between Product and ProductGroup schema?

Product schema describes an individual sellable item with its own price, image, and SKU. ProductGroup describes the umbrella entity that variants belong to (a hoodie that comes in 5 colors). The ProductGroup itself is not directly sold; the variant Products are. Schema.org treats them as separate types linked via isVariantOf and hasVariant properties.

How do I test my rich snippet eligibility on Shopify?

Use Google’s Rich Results Test at search.google.com/test/rich-results. Paste your product page URL, run the test, confirm “Eligible for Product results” appears. Address any errors or warnings shown in the report. Re-test after every theme change, app install that touches schema, or major Shopify update.

Why is my product showing in Google but without a rich snippet?

Three common causes: schema is invalid (run Rich Results Test to confirm), the page is too new and Google has not yet decided to render rich results (typically takes 1 to 4 weeks), or the page’s authority is low. Eligibility for rich snippets does not guarantee they appear; Google chooses based on context and authority.

Do I need ProductGroup schema for combined listings to rank?

Not for ranking specifically. Each child product page can rank on its own Product schema. ProductGroup helps Google understand the variant relationship, which improves how the catalog gets surfaced in AI agent responses and may help Google choose the right page for variation-specific queries. Useful but not strictly required for SEO.

Will adding extra schema slow down my product page?

No. JSON-LD is a small inline script (typically a few KB) that does not block rendering or slow page load meaningfully. Schema is a render-time win because Google reads it server-side without slowing your storefront.

Should I use AggregateOffer or Offer for variant products?

If your variants share the same price, use Offer with the single price. If variants have different prices (size XS at $79, size XXL at $89), use AggregateOffer with lowPrice and highPrice. Google renders AggregateOffer as a price range in the rich snippet, which can be more accurate but slightly less prominent than a single price.

One closing tip. Once your schema is right, do nothing for two weeks. Google needs time to recrawl and decide whether to render rich snippets. Resist the urge to keep tweaking. Test once, ship once, wait, then evaluate.

Byumid
Updated

Read Next