ProductGroup Schema

TL;DR — ProductGroup schemaProductGroup schema is structured data that groups product variants — like a shirt's sizes and colors — under one parent so Google understands they're options of the same item, not separate products. It wraps individual Product markup via hasVariant/variesBy/productGroupID; it doesn't replace it. is code that tells Google “all these variations — the small green shirt, the large blue one — are the same product in different options, not separate products.” Each variation still gets its own product markupProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two.; ProductGroup just wraps them together. It does not replace product markup, and it does not make a variant rank higher — it helps Google understand your catalog and can make your listings eligible to show variant info.

What ProductGroup schema is

If you sell a coat in three colors and five sizes, that’s one coat sold in 15 combinations. To a search engine, 15 near-identical product pages can look like 15 unrelated products unless you tell it otherwise.

ProductGroup schema is the structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. that does the telling. It sits above your individual product listings and says “these belong together — they’re the same item in different options.” Google added support for it in February 2024.

Think of it as a parent folder:

• The parent is the ProductGroup — “Wool winter coat.”
• The children are the individual Product variants — each color/size combo, with its own price, photo, stock status, and unique ID.

The important part: it’s additive, not a replacement

This trips up almost everyone the first time. ProductGroup does not replace your product markup. Every variant is still a full Product — it keeps its own SKU, price, image, and availability. ProductGroup is a wrapper that ties those Products together. You’re adding markup, not swapping it out.

What it does for you

Marking up your variants this way makes your products eligible to show variant information in Google’s shopping/merchant listings — the “also comes in these colors” kind of display. As with all schema, “eligible” is the key word: it’s not a ranking boost, and it’s never guaranteed. It helps Google understand your products, which is the point. Evidence for this claim Google supports ProductGroup with associated variant properties to describe product variants for merchant listings. Scope: Google Search product-variant documentation; eligibility is not a ranking promise. Confidence: high · Verified: 2026-07-14 Google: Product variants

Two things to know before you go deeper

• Bing doesn’t read ProductGroup schema (as of the latest word from Microsoft). So this is mainly a Google feature. More on that in the Advanced tab.
• This is the schema/code side of variants. Whether a given variant should even get its own page in the first place is a separate strategy question — I cover that decision (and the platform differences) in the product variant SEOProduct variant SEO is deciding how search engines crawl, index, and rank a product sold in multiple options (size, color, material). The job is sorting which variants deserve their own indexable URL and which should be consolidated to a base URL with a canonical. guide.

Want the full version — the three core properties, the full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL rule for variesBy, how productGroupID differs from Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads.’s item_group_id, a complete JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. example, and the common mistakes? Switch to the Advanced tab.

TL;DR — ProductGroup (Google’s Feb 2024 addition) wraps variant Product objects under one parent so Google understands “same item, different options.” It’s additive — each variant keeps full Product markup (sku/gtin, offers, image, availability). Link them with hasVariant (nested, single-page sites) or isVariantOf + inProductGroupWithID (flat, multi-page sites); declare the varying axes with variesBy — which must use full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URLs (https://schema.org/color), not plain strings (the #1 implementation mistake — validates either way, but grouping quietly won’t trigger in practice, which isn’t a documented Google behavior); and share a productGroupID (plain text parent sku, not a URL). productGroupID is not Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads.’s item_group_id — separate systems, nothing auto-syncs them, so use matching values on purpose. Only name is strictly required. And Bing doesn’t consume ProductGroup at all (Fabrice Canel, Sept 2024). Schema aids understanding and merchant-listing eligibility — it isn’t a ranking factor.

Where this sits

This is the schema-implementation deep dive — the full JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., the property-by-property reference, the Merchant Center reconciliation, and the troubleshooting. The upstream strategy question — should a given variant get its own indexable URL at all, and how do Shopify/WooCommerceWooCommerce SEO is optimizing a WooCommerce store — which runs as a free plugin on WordPress, not as a standalone platform — to rank in organic search. Because you control the whole stack (templates, URLs, plugins, server), the ceiling is high and the ways to misconfigure it are many./BigCommerceBigCommerce SEO is the technical, on-page, and content work you do on a store built on BigCommerce — a hosted SaaS ecommerce platform that ships with more native SEO controls than most of its rivals (editable robots.txt, custom URL structures, auto sitemaps, and automatic 301s), while still leaving faceted navigation, multi-storefront hreflang, and review schema for you to handle./Magento differ — is its own topic (product variant SEO). This article assumes you’ve already made those calls and now need the markup right. It also sits under the broader schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hubs, and it’s a sibling of Product schemaProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two. (for a single, non-varying item, plain Product is all you need — ProductGroup is for a family of variants).

Why ProductGroup exists

Google’s own framing: “To help Google better understand which products are variations of the same parent product, use the ProductGroup class with associated properties variesBy, hasVariant, and productGroupID to group such variants together.” The motivating categories are exactly what you’d expect — “apparel, shoes, furniture, electronic devices, and luggage… sold in different variations (for example various sizes, colors, materials, or patterns).”

The payoff is eligibility, not ranking: “Adding this markup also makes your products eligible for display with variant information in merchant listing experiences.” Same caveat that applies to all structured data — it aids understanding and rich-result eligibility, it doesn’t move you up the results.

It’s additive — this is the mental model that prevents most mistakes

ProductGroup wraps Product; it doesn’t replace it. The ProductGroup object itself isn’t offered for sale — it has no single price, because “the coat” costs different amounts depending on which variant you buy. Every variant remains a full Product with its own sku/gtin, image, offers, and availability. If you find yourself trying to put a single offers/price on the ProductGroup, stop — that’s the tell that you’ve confused the wrapper for the thing being sold.

The three core properties

hasVariant (and isVariantOf)

hasVariant is “a nested Product property that is one of the variants of the ProductGroup property… A ProductGroup typically has multiple nested variant Product properties.” You put your variant Product objects inside the group.

The inverse also exists: “a variant Product property can reference back to its parent ProductGroup using the isVariantOf property on the Product property.” Which one you use depends on your site’s URL structureURL structure is how the parts of a web address — scheme, domain, path, query string, and fragment — are organized and formatted. It mostly affects crawling, usability, and how engines understand a page, not rankings directly. (next section).

variesBy — full schema.org URLs, not plain strings

variesBy declares “aspects by which the variants in the ProductGroup vary (for example, size or color).” The critical detail, verbatim from Google’s properties table: “Reference these variant-identifying properties through their full Schema.org URL.”

That means:

"variesBy": ["https://schema.org/size", "https://schema.org/color"]

not "variesBy": ["size", "color"]. This is the single most common implementation mistake in this entire topic. What’s documented: Google’s property table requires the full URL form — nothing more specific than that. What’s not documented: Google doesn’t publish what happens if you skip it. In my own testing and consistent with other practitioners’ reports, the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. still passes syntax validation and nothing errors out, but the enhanced grouping behavior doesn’t trigger — treat that as a strongly observed pattern, not an official Google statement, and verify it against your own markup rather than taking it as gospel.

The supported dimensions are https://schema.org/color, https://schema.org/size, https://schema.org/suggestedAge, https://schema.org/suggestedGender, https://schema.org/material, and https://schema.org/pattern.

productGroupID — plain text, and not item_group_id

productGroupID is “the identifier of the product group (also known as the parent sku). This identifier must be provided for the ProductGroup property or, alternatively, using inProductGroupWithID property for variants.” It’s a plain text identifier — Google’s own example is "44E01" — not a URL. Don’t over-generalize the variesBy “full schema.org URL” rule to this field; they’re different rules for different jobs.

One hard constraint: “If you provide the identifier for both the ProductGroup property and its variant Product properties, they must match.” Google’s docs state the requirement but don’t document what happens when it’s violated. Based on my own testing (not a documented Google failure mode), a typo or a template/environment leak that changes the value on one variant page drops that variant out of the group with no visible error — the page just stops being read as part of the family. Treat that as observed behavior worth verifying yourself, not an official spec.

Two implementation patterns: nested vs. flat

Your URL structureURL structure is how the parts of a web address — scheme, domain, path, query string, and fragment — are organized and formatted. It mostly affects crawling, usability, and how engines understand a page, not rankings directly. decides which pattern you use.

Single-page sites — nested (hasVariant). All variants are selectable on one URL (via dropdowns/swatches). “For single-page websites only: The URL (without variant selectors) where the ProductGroup property is located.” There’s exactly one canonical URL for the whole group, and you nest every variant Product inside the ProductGroup via hasVariant.

Multi-page sites — flat (isVariantOf + inProductGroupWithID). Each variant has its own dedicated URL. Here “this doesn’t apply since there is no single canonical URLHow search engines pick one canonical URL among duplicates and consolidate signals onto it. representing the ProductGroup property.” Each page must carry full, self-contained markup for the entities defined on that page — you don’t share one block across pages. Every variant Product references its parent with isVariantOf, and the group link is carried by inProductGroupWithID: “Each product group must have a unique ID in its corresponding structured data markup, specified with the inProductGroupWithID property.”

Either way, “Each variant must have a unique ID in its corresponding structured data markup (for example, using the sku or gtin properties).”

One more requirement people miss on multi-page setups: variants must be reachable by a distinct, preselectable URL. Google: “The site must have the ability to preselect each variant directly with a distinct URL (using URL query parameters), for example https://www.example.com/winter_coat/size=small&color=green.” A variant that only appears after a client-side click, with no URL to point at, can’t be validated or indexed as its own thing.

Required vs. recommended

• Required on ProductGroup: just name (e.g., "Wool winter coat").
• Recommended: variesBy, hasVariant, productGroupID, brand, description, aggregateRating, review, hasAdultConsideration, and (single-page sites only) url.

Technically only name is required — but variesBy and productGroupID are functionally load-bearing. Skip them and the JSON-LD validates while the grouping behavior you wanted never shows up. (aggregateRating and review here are the same types you’d use standalone — see the AggregateRating and Review schemaReview schema (schema.org/Review) is structured data for a single critic's or user's evaluation of one specific thing — one author, one itemReviewed, one reviewRating — distinct from AggregateRating, which summarizes many reviews into an average. deep dives.)

productGroupID vs. Merchant Center’s item_group_id — the reconciliation nobody explains

This is the confusion point that most competitor content skips entirely, so it’s worth being precise.

• productGroupID is a schema.org / on-page structured data field. It feeds organic Search’s understanding of the page.
• item_group_id is a Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. product-feed attribute. Merchant Center: “Use the item group ID [item_group_id] attribute to group product variants in your product data.” It feeds Shopping ads and free listings.

They are two separate systems, and Google does not automatically sync them. Best practice — and this is echoed across the better third-party implementation guides — is to use the same identifier value for both, so your feed and your markup agree on which SKUs belong together. A mismatch doesn’t necessarily break either system outright, but it removes the reinforcing signal and can produce inconsistent grouping between Shopping surfaces and organic rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show..

(A footnote on casing: Merchant Center’s help sometimes writes productGroupId lowercase-d where Search Central’s docs use productGroupID. That’s a cosmetic inconsistency in Google’s own docs, not a mistake on your end — follow Search Central’s productGroupID in your JSON-LD.)

The consistency discipline here is the same one that governs canonicals and variant URLs generally: your signals should agree with each other, or you’re handing Google a reason to guess.

Bing does not support ProductGroup

Here’s the differentiator most guides get wrong or omit: Bing does not currently consume schema.org ProductGroup markup. Microsoft’s Fabrice Canel, responding directly to a question about whether Bing supports schema.org/ProductGroup, said Bing does not yet support it, but that it’s “on our radar” and the team is “closely monitoring its adoption.” (Reported by Search Engine Roundtable, covering a September 2024 exchange on X — a secondary report of a first-party statement, not a Microsoft doc, so treat it as such.)

Bing’s Webmaster Tools structured-data help is a generic overview of supported formats with no ProductGroup-, variesBy-, or productGroupID-specific content. Bing’s Shopping variant grouping runs through a feed-side itemGroupId field in Microsoft Advertising — the analog of Google’s item_group_id, not on-page schema. So: implement ProductGroup for Google, and handle Bing Shopping variants through the Microsoft Advertising feed, not markup.

A note on dynamic markup

Google’s own caution: “Be aware that dynamically-generated markup can make Shopping crawls less frequent and less reliable, which can be an issue for fast-changing content like product availability and price.” If your variant offers/availability are JS-injected, weigh that against server-renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. the markup for the fields that change often.

Validate before you ship

• Rich Results Test — checks eligibility and surfaces required-property errors for the merchant-listing/variant experience.
• Schema Markup Validator (schema.org) — validates the ProductGroup/Product types themselves, independent of Google features.
• Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. — the merchant-listings/product-snippet enhancement reports show eligibility and errors at scale post-deploy; URL Inspection shows how a specific page was read.

Remember what “valid” does and doesn’t tell you: a plain-string variesBy passes validation and, in my testing, still doesn’t trigger grouping. Validation catches syntax and required-property gaps, not this kind of semantic failure (which Google doesn’t document either way) — for those, check by hand that your variesBy values are full URLs and your productGroupID matches across the group.

For where this fits the bigger picture, see the broader structured data and schema markup hubs this article lives under.

AI summary

A condensed take on the Advanced version:

• What it is: ProductGroup (Google, Feb 2024) wraps variant Product objects under one parent so Google understands “same item, different options” rather than unrelated products. Eligibility for variant display in merchant listings — not a ranking factor.
• Additive, not a replacement: every variant stays a full Product (sku/gtin, offers, image, availability); ProductGroup is the wrapper and isn’t sold on its own (no single price on the group).
• Three core properties: hasVariant nests variants (or isVariantOf points back up); variesBy lists the varying axes and must use full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URLs (https://schema.org/color, not "color") — the #1 implementation mistake, and in practice (not something Google documents) it validates fine while grouping quietly doesn’t trigger; productGroupID is a plain text parent sku (not a URL, e.g. "44E01"), and if set on both group and variants the values must match — Google documents the match rule but not what happens on a mismatch.
• Two patterns: nested (hasVariant, single-page sites, one canonical URLHow search engines pick one canonical URL among duplicates and consolidate signals onto it. for the group) vs. flat (isVariantOf + inProductGroupWithID, multi-page sites, full self-contained markup per page). Variants need unique sku/gtin and a distinct preselectable URL.
• Required vs. recommended: only name is required; variesBy + productGroupID are functionally essential even though technically recommended.
• productGroupID ≠ item_group_id: on-page schema (organic Search) vs. Merchant Center feed attribute (Shopping/free listingsFree product listings (originally launched as \"Surfaces across Google\" in 2020) are unpaid, organic product placements Google generates from your Merchant Center feed or on-page Product structured data. There's no bid and no CPC — Google matches your product data to a query and decides whether and where to show it — across the Shopping tab, Google Search (Popular Products grids), Images, Lens, Maps/Business Profile, YouTube, and Gemini; AI Mode and AI Overviews aren't on Google's official surfaces list, though practitioner reporting links them to the same eligibility pool. They're enabled by default in most cases for new Merchant Center accounts.) — separate systems, nothing auto-syncs, use matching values on purpose.
• Bing doesn’t support ProductGroup (Fabrice Canel, Sept 2024, via Search Engine Roundtable). Bing ShoppingMicrosoft's free platform (inside Microsoft Advertising, formerly 'Bing Merchant Center') where retailers create a store and submit a product feed. One feed powers both free Product Listings on the Bing Shopping tab and paid Microsoft Shopping Campaigns — the Bing/Copilot-side twin of Google Merchant Center. As of 2026 it's also the product-data foundation Copilot draws on for AI-assisted shopping and checkout. variants run through Microsoft Advertising’s feed-side itemGroupId, not markup.
• Watch dynamic markup (less reliable Shopping crawls for price/availability). Validate with Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test + schema.org Validator, but remember plain-string variesBy validates and still fails.

Official documentation

Primary-source documentation for ProductGroup and variant markup.

Google

• Product variant structured data (ProductGroup, Product) — the single authoritative page: ProductGroup, hasVariant, isVariantOf, variesBy, productGroupID, the full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL rule, required/recommended properties, and the single-page vs. multi-page rules.
• Adding structured data support for Product Variants (Feb 2024 blog) — the announcement that introduced the properties.
• Intro to Product structured data — the general Product page (Product snippets / merchant listings). Note: it does not cover ProductGroup — that’s the separate page above.
• Google Merchant Center — Item group ID [item_group_id] — the product-feed attribute for grouping variants, and its schema.org cross-references.

Bing / Microsoft

• Bing Webmaster Tools — Marking up your site with structured data — a generic overview of supported formats; no ProductGroup-, variesBy-, or productGroupID-specific content.

schema.org

• schema.org/ProductGroup — the vocabulary page: authoritative property list and Product/Thing inheritance (no implementation examples or Google-specific guidance).

Quotes from the source

On-the-record statements from Google (and reported statements from Microsoft). Where a page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — purpose and eligibility

• “To help Google better understand which products are variations of the same parent product, use the ProductGroup class with associated properties variesBy, hasVariant, and productGroupID to group such variants together.” Jump to quote
• “Many types of products such as apparel, shoes, furniture, electronic devices, and luggage are sold in different variations (for example various sizes, colors, materials, or patterns).” Jump to quote
• “Adding this markup also makes your products eligible for display with variant information in merchant listing experiences.” Jump to quote

Google docs — the properties

• variesBy: “Aspects by which the variants in the ProductGroup vary… Reference these variant-identifying properties through their full Schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL.” Jump to quote
• hasVariant: “A nested Product property that is one of the variants of the ProductGroup property, if applicable. A ProductGroup typically has multiple nested variant Product properties.” Jump to quote
• isVariantOf: “Alternatively, a variant Product property can reference back to its parent ProductGroup using the isVariantOf property on the Product property.” Jump to quote
• productGroupID: “The identifier of the product group (also known as the parent sku). This identifier must be provided for the ProductGroup property or, alternatively, using inProductGroupWithID property for variants.” Jump to quote
• On matching IDs: “If you provide the identifier for both the ProductGroup property and its variant Product properties, they must match.” Jump to quote

Google docs — unique IDs and URLs

• “Each variant must have a unique ID in its corresponding structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. markup (for example, using the sku or gtinProduct identifiers are the standardized values — GTIN (Global Trade Item Number), MPN (Manufacturer Part Number), and brand — that shopping feeds like Google Merchant Center and Microsoft Merchant Center use to match a product listing to the correct item in their catalog. A GTIN alone is usually enough; without one, brand + MPN is the fallback; products with none declare that with the identifier_exists attribute. properties).” Jump to quote
• “The site must have the ability to preselect each variant directly with a distinct URL (using URL query parametersThe `?key=value` data tacked onto the end of a URL after a question mark — used for tracking, sessions, filtering, sorting, and search — and one of the biggest sources of duplicate URLs and wasted crawling in SEO.), for example https://www.example.com/winter_coat/size=small&color=green.” Jump to quote
• On dynamic markup: “Be aware that dynamically-generated markup can make Shopping crawls less frequent and less reliable, which can be an issue for fast-changing content like product availability and price.” Jump to quote

Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. — item_group_id

• “Use the item group ID [item_group_id] attribute to group product variants in your product data.” Jump to quote

John Mueller, Google (via Search Engine Roundtable’s verbatim reproduction of his Feb 2024 LinkedIn post)

• “Product variants in ecommerce are complicated - what do you do with t-shirts in different colors? Folks here Google worked hard to come up with structured data markup & support for it… The changes are also live in the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Testing tool and in the Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. reports for these types.” Read the coverage

Fabrice Canel, Microsoft Bing (reported, not a first-party doc)

• Responding to whether Bing supports schema.org/ProductGroup, Canel said Bing does not yet support it, but that it’s “on our radar” and the team is “closely monitoring its adoption.” Coverage Relayed via Search Engine Roundtable’s coverage of a September 2024 exchange on X; a secondary report of a first-party statement, not a Microsoft documentation page.

A complete ProductGroup JSON-LD example

Google’s own doc example is intentionally minimal — one variant, no offers. Here’s a fuller, single-page (nested hasVariant) version with two variants, offers, gtin, image, and brand — the shape you’d actually ship. Note variesBy uses full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URLs, and productGroupID is a plain string.

{
  "@context": "https://schema.org/",
  "@type": "ProductGroup",
  "name": "Wool winter coat",
  "description": "A warm wool winter coat, available in several sizes and colors.",
  "url": "https://www.example.com/winter-coat",
  "brand": {
    "@type": "Brand",
    "name": "ExampleCo"
  },
  "productGroupID": "44E01",
  "variesBy": [
    "https://schema.org/size",
    "https://schema.org/color"
  ],
  "hasVariant": [
    {
      "@type": "Product",
      "sku": "44E01-S-GRN",
      "gtin": "0123456789012",
      "name": "Wool winter coat, small, green",
      "image": "https://www.example.com/photos/44E01-S-GRN.jpg",
      "size": "small",
      "color": "Green",
      "offers": {
        "@type": "Offer",
        "url": "https://www.example.com/winter-coat?size=small&color=green",
        "price": "119.99",
        "priceCurrency": "USD",
        "availability": "https://schema.org/InStock"
      }
    },
    {
      "@type": "Product",
      "sku": "44E01-L-BLU",
      "gtin": "0123456789029",
      "name": "Wool winter coat, large, blue",
      "image": "https://www.example.com/photos/44E01-L-BLU.jpg",
      "size": "large",
      "color": "Blue",
      "offers": {
        "@type": "Offer",
        "url": "https://www.example.com/winter-coat?size=large&color=blue",
        "price": "119.99",
        "priceCurrency": "USD",
        "availability": "https://schema.org/OutOfStock"
      }
    }
  ]
}

Things to notice:

• The ProductGroup has no offers/price of its own — price lives on each variant’s Offer, because the group isn’t a single sellable thing.
• Each variant carries a unique sku (and here a gtin), its own image, its own availability, and the size/color values that match what variesBy declared.
• Availability is per-variant — the small green coat is InStock, the large blue one OutOfStock. That’s the correct way to handle a partially-stocked group (see the out-of-stock products guide for how to signal this without dropping the variant).

The multi-page (flat) variant of the same setup

If each variant lives on its own URL, you don’t nest — each page carries its own self-contained Product that points back up with isVariantOf and the shared group ID via inProductGroupWithID:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "sku": "44E01-S-GRN",
  "gtin": "0123456789012",
  "name": "Wool winter coat, small, green",
  "image": "https://www.example.com/photos/44E01-S-GRN.jpg",
  "size": "small",
  "color": "Green",
  "inProductGroupWithID": "44E01",
  "isVariantOf": {
    "@type": "ProductGroup",
    "productGroupID": "44E01",
    "variesBy": [
      "https://schema.org/size",
      "https://schema.org/color"
    ]
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/winter-coat/small-green",
    "price": "119.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Every variant page repeats this pattern with its own IDs and offer, and the same productGroupID ("44E01") ties them together. Keep that ID identical across all variant pages and aligned with your Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. item_group_id.

Should you use ProductGroup, and which pattern?

Walk the tree to land on the right markup decision for your setup.

Common ProductGroup mistakes

The traps, and what’s actually true:

ProductGroup implementation checklist

Work through this in order — each item maps to a specific gotcha covered above.

• Decide your pattern first. All variants selectable on one URL → nested (hasVariant). Each variant on its own URL → flat (isVariantOf + inProductGroupWithID). Don’t mix patterns on the same group.
• Keep every variant a full Product. Each one still has its own sku/gtin, image, offers, and availability — ProductGroup never carries a single price of its own.
• Write variesBy as full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URLs, e.g. https://schema.org/color and https://schema.org/size — not "color" / "size". This is the #1 implementation mistake; it validates either way, and grouping quietly doesn’t trigger without the URL form in my testing (not something Google documents), so check it by eye.
• Set productGroupID as a plain-text identifier (parent sku, e.g. "44E01") — never a URL. Different rule from variesBy; don’t conflate them.
• Match productGroupID (or inProductGroupWithID) across every variant. Google documents the match requirement but not what happens if it’s violated; in my testing, a typo on one variant page drops it from the group with no error.
• Give every variant a unique ID via sku or gtin.
• Confirm every variant has a distinct, preselectable URL (query params are fine, e.g. ?size=small&color=green). A JS-only state change with no URL can’t be validated or indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. as its own variant.
• Align productGroupID with Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads.’s item_group_id. They’re separate systems and nothing auto-syncs them — use the same value on purpose.
• Server-render fast-changing fields (price, availability) where possible — Google warns dynamically-generated markup can make Shopping crawls less frequent and reliable.
• Validate, then verify by hand. Run the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test and the schema.org Validator — then manually re-check variesBy URLs and productGroupID matching, since both pass validation even when broken.
• If you also target Bing, don’t rely on ProductGroup — it isn’t consumed at all (per Microsoft’s Fabrice Canel, Sept 2024). Handle Bing ShoppingMicrosoft's free platform (inside Microsoft Advertising, formerly 'Bing Merchant Center') where retailers create a store and submit a product feed. One feed powers both free Product Listings on the Bing Shopping tab and paid Microsoft Shopping Campaigns — the Bing/Copilot-side twin of Google Merchant Center. As of 2026 it's also the product-data foundation Copilot draws on for AI-assisted shopping and checkout. variants through Microsoft Advertising’s feed-side itemGroupId instead.

ProductGroup quick-reference

productGroupID vs. item_group_id vs. inProductGroupWithID

Nothing auto-syncs these across systems — use the same value in all three so organic and Shopping agree on which SKUs belong together.

Nested vs. flat pattern

Property format rules

Catch the #1 implementation mistake: variesBy as plain strings

variesBy values that skip the full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL prefix are the single most common mistake in this topic — the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. still validates, so nothing errors out, and in my testing grouping quietly doesn’t trigger (Google’s docs require the full-URL form but don’t document what happens if you skip it). These snippets catch it directly instead of relying on eyeballing the markup.

Regex: flag a bad variesBy array in raw JSON-LD

Run this over extracted JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. source (e.g. a Screaming Frog custom extraction export, or any raw HTML/text dump) to find variesBy arrays containing a value that isn’t a full schema.org URL:

"variesBy"\s*:\s*\[\s*((?:"(?!https://schema\.org/)[^"]*"\s*,?\s*)+)\]

• "variesBy"\s*:\s*\[ — matches the start of the property and its opening bracket, allowing for whitespace formatting differences.
• (?:"(?!https://schema\.org/)[^"]*"\s*,?\s*)+ — the capture group: matches one or more quoted strings where a negative lookahead (?!https://schema\.org/) rules out anything that already starts with the correct prefix. If this group matches anything at all, at least one entry in the array is a bad plain string like "color" or "size" instead of a full URL.
• A match means: stop and fix that array before shipping — it will validate clean and still fail to trigger grouping.

Chrome DevTools Console snippet: audit the live page’s JSON-LD

Paste into the Console on any page you expect to carry ProductGroup markup. It pulls every JSON-LD block, walks into ProductGroup objects (including ones nested under isVariantOf), and reports any variesBy entry that isn’t a full schema.org URL:

(function () {
  const blocks = [...document.querySelectorAll('script[type="application/ld+json"]')];
  const findings = [];
  blocks.forEach((block, i) => {
    let data;
    try {
      data = JSON.parse(block.textContent);
    } catch (e) {
      findings.push(`Block ${i}: invalid JSON (${e.message})`);
      return;
    }
    const items = Array.isArray(data) ? data : [data];
    items.forEach((item) => {
      const groups = [];
      if (item['@type'] === 'ProductGroup') groups.push(item);
      if (item.isVariantOf && item.isVariantOf['@type'] === 'ProductGroup') groups.push(item.isVariantOf);
      groups.forEach((g) => {
        const bad = (g.variesBy || []).filter((v) => !String(v).startsWith('https://schema.org/'));
        if (bad.length) findings.push(`Block ${i}: bad variesBy values -> ${JSON.stringify(bad)}`);
        if (g.productGroupID && /^https?:\/\//.test(g.productGroupID)) {
          findings.push(`Block ${i}: productGroupID looks like a URL, should be plain text -> ${g.productGroupID}`);
        }
      });
    });
  });
  console.log(findings.length ? findings.join('\n') : 'No ProductGroup issues found in this page\'s JSON-LD.');
})();

XPath for Screaming Frog: extract productGroupID across variant pages

Use a custom extraction to pull the productGroupID value straight out of the JSON-LD script tag, then compare the extracted values across your crawled variant URLs to spot a mismatch:

//script[@type="application/ld+json"]

Extract the full text of each matching node, then check the extracted productGroupID (and inProductGroupWithID on flat/multi-page setups) is identical across every URL that’s supposed to belong to the same group — a single differing value means that page has likely dropped out of the group with no error thrown, based on testing (Google’s docs require the match but don’t document mismatch behavior).

Test yourself: ProductGroup Schema

Five quick questions on ProductGroup, its core properties, and the gotchas. Pick an answer for each, then check.

Resources worth your time

My related writing

I haven’t published a piece specifically on ProductGroup schemaProductGroup schema is structured data that groups product variants — like a shirt's sizes and colors — under one parent so Google understands they're options of the same item, not separate products. It wraps individual Product markup via hasVariant/variesBy/productGroupID; it doesn't replace it. — this article is the dedicated treatment. The closest adjacent things I’ve written that inform it:

• Google Uses ~40 Canonicalization Signals — Here’s What That Means — the “keep your signals consistent” discipline that underpins matching productGroupID across variants (and aligning it with item_group_id).
• The Myth of the Duplicate Content Penalty (Search Engine Land) — why grouping variants as one item in options, rather than fearing them as duplicates, is the right mental model. There’s no duplicate-content penalty to “fix” with ProductGroup — it’s about understanding, not avoiding a fine.

For the strategy layer — whether a variant should even get its own URL, and how Shopify/WooCommerceWooCommerce SEO is optimizing a WooCommerce store — which runs as a free plugin on WordPress, not as a standalone platform — to rank in organic search. Because you control the whole stack (templates, URLs, plugins, server), the ceiling is high and the ways to misconfigure it are many./BigCommerceBigCommerce SEO is the technical, on-page, and content work you do on a store built on BigCommerce — a hosted SaaS ecommerce platform that ships with more native SEO controls than most of its rivals (editable robots.txt, custom URL structures, auto sitemaps, and automatic 301s), while still leaving faceted navigation, multi-storefront hreflang, and review schema for you to handle./Magento differ — see the product variant SEOProduct variant SEO is deciding how search engines crawl, index, and rank a product sold in multiple options (size, color, material). The job is sorting which variants deserve their own indexable URL and which should be consolidated to a base URL with a canonical. guide on this site. For the fundamentals, the schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hubs, and the sibling Product schemaProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two. deep dive.

From around the industry

• Product variant structured data (Google Search Central) — the authoritative reference; read it alongside this for the full property tables.
• Adding structured data support for Product Variants (Google Search Central blog) — the Feb 2024 announcement.
• Item group ID [item_group_id] (Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. Help) — the feed-side attribute and its schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. cross-references.
• New Google Search Support For Product Variant Structured Data (Search Engine Roundtable) — the Feb 2024 launch recap, with John Mueller’s verbatim LinkedIn post.
• Bing does not support ProductGroup markup (Search Engine Roundtable) — the Fabrice Canel statement (Sept 2024).
• Google adds support for product variants (Search Engine Land) — same-day announcement coverage.
• Google To Display More Product Variants With New Markup (Search Engine Journal) — the SEJ take on the launch.
• Schema piece: ProductGroup (Yoast Developer Portal) — real JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. examples and Yoast’s default productGroupID-from-SKU behavior (plugin-specific).
• How to implement ProductGroup schema (Go Fish Digital) — plain-English “why this exists” framing.
• schema.org/ProductGroup — the vocabulary itself, straight from the source.

ProductGroup Schema

ProductGroup schema is structured data that groups product variants — like a shirt's sizes and colors — under one parent so Google understands they're options of the same item, not separate products. It wraps individual Product markup via hasVariant/variesBy/productGroupID; it doesn't replace it.

Related: Schema Markup, Product Variant SEO, Structured Data

ProductGroup Schema

ProductGroup is a schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Google structured-data type that wraps a set of Product variants — a shirt in different sizes and colors, a coat in several materials — under one parent so search engines understand they’re the same underlying item in different options, not unrelated products. It does not replace Product markup: every individual variant is still marked up as a full Product (its own sku/gtin, price, image, availability), and ProductGroup sits above them, tying them together.

Three properties do the linking. hasVariant nests the variant Product objects inside the group (or, from the variant’s side, isVariantOf points back up to the parent). variesBy lists which attributes differ — color, size, material, pattern, suggestedAge, suggestedGender — and, per Google’s docs, its values must be full schema.org URLs (https://schema.org/color), not plain strings like "color"; plain strings validate as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. but silently fail to trigger the grouping behavior. productGroupID is a shared parent identifier (the “parent sku”) — a plain text value, not a URL.

Two things to keep straight:

• productGroupID (schema.org) is not Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads.’s item_group_id. They’re separate systems — one feeds organic Search’s understanding of the page, the other feeds Shopping ads and free listingsFree product listings (originally launched as \"Surfaces across Google\" in 2020) are unpaid, organic product placements Google generates from your Merchant Center feed or on-page Product structured data. There's no bid and no CPC — Google matches your product data to a query and decides whether and where to show it — across the Shopping tab, Google Search (Popular Products grids), Images, Lens, Maps/Business Profile, YouTube, and Gemini; AI Mode and AI Overviews aren't on Google's official surfaces list, though practitioner reporting links them to the same eligibility pool. They're enabled by default in most cases for new Merchant Center accounts.. Nothing auto-syncs them; best practice is to use the same value for both so your markup and your feed agree.
• Bing does not currently consume ProductGroup markup. Per Microsoft’s Fabrice Canel (reported September 2024), it’s “on their radar” but not shipped. Bing ShoppingMicrosoft's free platform (inside Microsoft Advertising, formerly 'Bing Merchant Center') where retailers create a store and submit a product feed. One feed powers both free Product Listings on the Bing Shopping tab and paid Microsoft Shopping Campaigns — the Bing/Copilot-side twin of Google Merchant Center. As of 2026 it's also the product-data foundation Copilot draws on for AI-assisted shopping and checkout. variant grouping runs through Microsoft Advertising’s feed-side itemGroupId, not on-page schema.

Adding ProductGroup markup makes products eligible for variant-aware display in Google’s merchant listing experiences — eligibility, not a ranking boost. Structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. isn’t a direct ranking factor.

Related: Schema Markup, Product Variant SEO, Structured Data

Changelog