Panduan ProductGroup Schema

TL;DR — ProductGroup schema adalah code itu tells Google “all these variations — the small green shirt, the large blue one — are the same product in different options, not separate products.” (terjemahan) “semua ini variations — kecil green shirt, besar blue one — adalah sama product di berbeda options, not separate products.” setiap variation masih gets -nya own product markup; ProductGroup hanya wraps them together. ini melakukan not replace product markup, dan ini melakukan not membuat sebuah variant peringkat higher — ini helps Google memahami Anda catalog dan dapat membuat Anda listings eligible untuk tampilkan variant info.

What ProductGroup schema adalah

jika Anda sell sebuah coat di three colors dan five sizes, itu’s one coat sold di 15 combinations. untuk sebuah mesin pencari, 15 near-identical product halaman dapat look like 15 unrelated products unless Anda tell ini otherwise.

ProductGroup schema adalah data terstruktur itu melakukan telling. ini sits above Anda individual product listings dan says “these belong together — they’re the same item in different options.” (terjemahan) “ini belong together — mereka’re yang sama item di berbeda options.” Google ditambahkan mendukung untuk ini di February 2024.

Think dari ini sebagai sebuah parent folder:

• parent adalah ProductGroup — “Wool winter coat.” (terjemahan) “Wool winter coat.”
• children adalah individual Product variants — setiap color/size combo, dengan -nya own price, photo, stock status, dan unique ID.

penting bagian: ini adalah additive, not sebuah replacement

ini trips up almost everyone pertama time. ProductGroup melakukan not replace Anda product markup. setiap variant adalah masih sebuah full Product — ini mempertahankan -nya own SKU, price, image, dan availability. ProductGroup adalah sebuah wrapper itu ties itu Products together. Anda’re menambahkan markup, not swapping ini out.

What ini melakukan untuk Anda

Marking up Anda variants ini cara membuat Anda products eligible untuk tampilkan variant informasi di Google’s shopping/merchant listings — “also comes in these colors” (terjemahan) “juga comes di ini colors” jenis dari display. sebagai dengan semua schema, “eligible” (terjemahan) “eligible” adalah key kata: ini adalah not sebuah peringkat boost, dan ini adalah tidak pernah guaranteed. ini helps Google memahami Anda products, which adalah poin. 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 untuk know sebelum Anda go deeper

• Bing doesn’t read ProductGroup schema (sebagai dari latest kata dari Microsoft). So ini adalah mainly sebuah Google fitur. More pada itu di Advanced tab.
• ini adalah schema/code side dari variants. Whether sebuah given variant seharusnya bahkan get -nya own halaman di pertama place adalah sebuah separate strategy pertanyaan — I cover itu decision (dan platform differences) di product variant SEO guide.

ingin full versi — three core properties, full schema.org URL aturan untuk variesBy, how productGroupID differs dari Merchant Center’s item_group_id, sebuah complete JSON-LD contoh, dan umum mistakes? Switch untuk Advanced tab.

TL;DR — ProductGroup (Google’s Feb 2024 addition) wraps variant Product objects di bawah one parent so Google understands “same item, different options.” (terjemahan) “sama item, berbeda options.” ini adalah additive — setiap variant mempertahankan full Product markup (sku/gtin, offers, image, availability). tautan them dengan hasVariant (nested, single-halaman situs) atau isVariantOf + inProductGroupWithID (flat, multi-halaman situs); declare varying axes dengan variesBy — which harus gunakan full schema.org URLs (https://schema.org/color), not plain strings ( #1 implementation mistake — validates either cara, tetapi grouping quietly won’t trigger dalam praktik, which isn’t sebuah documented Google perilaku); dan share sebuah productGroupID (plain text parent sku, not sebuah URL). productGroupID adalah not Merchant Center’s item_group_id — separate sistem, nothing auto-syncs them, so gunakan matching nilai pada purpose. hanya name adalah strictly diperlukan. dan Bing doesn’t consume ProductGroup di semua (Fabrice Canel, Sept 2024). Schema aids understanding dan merchant-listing eligibility — ini isn’t sebuah peringkat factor.

Where ini sits

ini adalah schema-implementation deep dive — full JSON-LD, property-oleh-property reference, Merchant Center reconciliation, dan troubleshooting. upstream strategy pertanyaan — seharusnya sebuah given variant get -nya own dapat diindeks URL di semua, dan how melakukan Shopify/WooCommerce/BigCommerce/Magento differ — adalah -nya own topic (product variant SEO). ini artikel assumes Anda’ve sudah dibuat itu panggilan dan now perlu markup right. ini juga sits di bawah broader schema markup dan data terstruktur hubs, dan ini adalah sebuah sibling dari Product schema (untuk sebuah single, non-varying item, plain Product adalah semua Anda perlu — ProductGroup adalah untuk sebuah family dari 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.” (terjemahan) “untuk help Google better memahami which products adalah variations dari yang sama parent product, gunakan ProductGroup class dengan associated properties variesBy, hasVariant, dan productGroupID untuk group such variants together.” motivating categories adalah exactly what Anda’d expect — “apparel, shoes, furniture, electronic devices, and luggage… sold in different variations (for example various sizes, colors, materials, or patterns).” (terjemahan) “apparel, shoes, furniture, electronic devices, dan luggage… sold di berbeda variations (misalnya various sizes, colors, materials, atau patterns).”

payoff adalah eligibility, not peringkat: “Adding this markup also makes your products eligible for display with variant information in merchant listing experiences.” (terjemahan) “menambahkan ini markup juga membuat Anda products eligible untuk display dengan variant informasi di merchant listing experiences.” sama caveat itu applies untuk semua data terstruktur — ini aids understanding dan rich-hasil eligibility, ini doesn’t move Anda up hasil.

ini adalah additive — ini adalah mental model itu mencegah sebagian besar mistakes

ProductGroup wraps Product; ini doesn’t replace ini. ProductGroup object itself isn’t offered untuk sale — ini memiliki no single price, because “the coat” (terjemahan) “ coat” costs berbeda amounts depending pada which variant Anda buy. setiap variant remains sebuah full Product dengan -nya own sku/gtin, image, offers, dan availability. jika Anda temukan yourself trying untuk put sebuah single offers/price pada ProductGroup, stop — itu’s tell itu Anda’ve confused wrapper untuk thing menjadi sold.

three core properties

hasVariant (dan isVariantOf)

hasVariant adalah “a nested Product property that is one of the variants of the ProductGroup property… A ProductGroup typically has multiple nested variant Product properties.” (terjemahan) “sebuah nested Product property itu adalah one dari variants dari ProductGroup property… sebuah ProductGroup typically memiliki multiple nested variant Product properties.” Anda put Anda variant Product objects inside group.

inverse juga exists: “a variant Product property can reference back to its parent ProductGroup using the isVariantOf property on the Product property.” (terjemahan) “sebuah variant Product property dapat reference back untuk -nya parent ProductGroup menggunakan isVariantOf property pada Product property.” Which one Anda gunakan depends pada Anda situs’s struktur URL (next bagian).

variesBy — full schema.org URLs, not plain strings

variesBy declares “aspects by which the variants in the ProductGroup vary (for example, size or color).” (terjemahan) “aspects oleh which variants di ProductGroup vary (untuk contoh, size atau color).” critical detail, verbatim dari Google’s properties table: “Reference these variant-identifying properties through their full Schema.org URL.” (terjemahan) “Reference ini variant-identifying properties melalui mereka full Schema.org URL.”

itu berarti:

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

not "variesBy": ["size", "color"]. ini adalah single sebagian besar umum implementation mistake di ini entire topic. What’s documented: Google’s property table memerlukan full URL form — nothing more spesifik daripada itu. What’s not documented: Google doesn’t publish what happens jika Anda skip ini. di my own testing dan consistent dengan lainnya practitioners’ reports, JSON-LD masih passes syntax validation dan nothing errors out, tetapi enhanced grouping perilaku doesn’t trigger — treat itu sebagai sebuah strongly observed pattern, not sebuah official Google statement, dan verify ini terhadap Anda own markup alih-alih taking ini sebagai gospel.

didukung dimensions adalah https://schema.org/color, https://schema.org/size, https://schema.org/suggestedAge, https://schema.org/suggestedGender, https://schema.org/material, dan https://schema.org/pattern.

productGroupID — plain text, dan not item_group_id

productGroupID adalah “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.” (terjemahan) “ identifier dari product group (juga known sebagai parent sku). ini identifier harus menjadi disediakan untuk ProductGroup property atau, alternatively, menggunakan inProductGroupWithID property untuk variants.” ini adalah sebuah plain text identifier — Google’s own contoh adalah "44E01" — not sebuah URL. Don’t di atas-generalize variesBy “full schema.org URL” (terjemahan) “full schema.org URL” aturan untuk ini field; mereka’re berbeda aturan untuk berbeda jobs.

One hard constraint: “If you provide the identifier for both the ProductGroup property and its variant Product properties, they must match.” (terjemahan) “jika Anda menyediakan identifier untuk both ProductGroup property dan -nya variant Product properties, mereka harus match.” Google’s docs state requirement tetapi don’t document what happens when ini adalah violated. berdasarkan my own testing (not sebuah documented Google failure mode), sebuah typo atau sebuah template/environment leak itu perubahan nilai pada one variant halaman drops itu variant out dari group dengan no terlihat error — halaman hanya stops menjadi read sebagai bagian dari family. Treat itu sebagai observed perilaku worth verifying yourself, not sebuah official spec.

Two implementation patterns: nested vs. flat

Anda struktur URL decides which pattern Anda gunakan.

Single-halaman situs — nested (hasVariant). semua variants adalah selectable pada one URL (via dropdowns/swatches). “For single-page websites only: The URL (without variant selectors) where the ProductGroup property is located.” (terjemahan) “untuk single-halaman situs web hanya: URL (without variant selectors) where ProductGroup property adalah located.” There’s exactly one canonical URL untuk whole group, dan Anda nest setiap variant Product inside ProductGroup via hasVariant.

Multi-halaman situs — flat (isVariantOf + inProductGroupWithID). setiap variant memiliki -nya own dedicated URL. Here “this doesn’t apply since there is no single canonical URL representing the ProductGroup property.” (terjemahan) “ini doesn’t apply since tidak ada single canonical URL representing ProductGroup property.” setiap halaman harus carry full, self-berisi markup untuk entities defined pada itu halaman — Anda tidak share one block di seluruh halaman. setiap variant Product references -nya parent dengan isVariantOf, dan group tautan adalah carried oleh inProductGroupWithID: “Each product group must have a unique ID in its corresponding structured data markup, specified with the inProductGroupWithID property.” (terjemahan) “setiap product group harus memiliki sebuah unique ID di -nya corresponding data terstruktur markup, specified dengan inProductGroupWithID property.”

Either cara, “Each variant must have a unique ID in its corresponding structured data markup (for example, using the sku or gtin properties).” (terjemahan) “setiap variant harus memiliki sebuah unique ID di -nya corresponding data terstruktur markup (misalnya, menggunakan sku atau gtin properties).”

One more requirement people miss pada multi-halaman setups: variants harus menjadi reachable oleh sebuah 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.” (terjemahan) “ situs harus memiliki ability untuk preselect setiap variant directly dengan sebuah distinct URL (menggunakan URL kueri parameters), misalnya undefined” sebuah variant itu hanya appears setelah sebuah client-side click, dengan no URL untuk poin di, dapat’t menjadi validated atau terindeks sebagai -nya own thing.

diperlukan vs. recommended

• diperlukan pada ProductGroup: hanya name (e.g., "Wool winter coat").
• Recommended: variesBy, hasVariant, productGroupID, brand, description, aggregateRating, review, hasAdultConsideration, dan (single-halaman situs hanya) url.

Technically hanya name adalah diperlukan — tetapi variesBy dan productGroupID adalah functionally muat-bearing. Skip them dan JSON-LD validates while grouping perilaku Anda wanted tidak pernah menampilkan up. (aggregateRating dan review here adalah yang sama jenis Anda’d gunakan standalone — see AggregateRating dan Review schema deep dives.)

productGroupID vs. Merchant Center’s item_group_id — reconciliation nobody menjelaskan

ini adalah confusion poin itu sebagian besar competitor konten skips entirely, so ini adalah worth menjadi precise.

• productGroupID adalah sebuah schema.org / pada-halaman data terstruktur field. ini feeds pencarian organik’s understanding dari halaman.
• item_group_id adalah sebuah Google Merchant Center product-feed attribute. Merchant Center: “Use the item group ID [item_group_id] attribute to group product variants in your product data.” (terjemahan) “gunakan item group ID [item_group_id] attribute untuk group product variants di Anda product data.” ini feeds Shopping ads dan free listings.

mereka adalah two separate sistem, dan Google melakukan not automatically sync them. Best practice — dan ini adalah echoed di seluruh better ketiga-party implementation guides — adalah untuk gunakan sama identifier nilai untuk both, so Anda feed dan Anda markup agree pada which SKUs belong together. sebuah mismatch doesn’t necessarily break either sistem outright, tetapi ini menghapus reinforcing signal dan dapat produce inconsistent grouping antara Shopping surfaces dan organic rich hasil.

(sebuah footnote pada casing: Merchant Center’s help sometimes writes productGroupId lowercase-d where Search Central’s docs gunakan productGroupID. itu’s sebuah cosmetic inconsistency di Google’s own docs, not sebuah mistake pada Anda end — ikuti Search Central’s productGroupID di Anda JSON-LD.)

consistency discipline here adalah yang sama one itu governs canonicals dan variant URLs umumnya: Anda signals seharusnya agree dengan setiap lainnya, atau Anda’re handing Google sebuah alasan untuk guess.

Bing melakukan not mendukung ProductGroup

Here’s differentiator sebagian besar guides get wrong atau omit: Bing melakukan not currently consume schema.org ProductGroup markup. Microsoft’s Fabrice Canel, responding directly untuk sebuah pertanyaan tentang whether Bing mendukung schema.org/ProductGroup, said Bing melakukan not yet mendukung ini, tetapi itu ini adalah “on our radar” (terjemahan) “pada kami radar” dan team adalah “closely monitoring its adoption.” (terjemahan) “closely monitoring -nya adoption.” (Reported oleh mesin pencari Roundtable, covering sebuah September 2024 exchange pada X — sebuah secondary report dari sebuah pertama-party statement, not sebuah Microsoft doc, so treat ini sebagai such.)

Bing’s Webmaster alat structured-data help adalah sebuah generic overview dari didukung formats dengan no ProductGroup-, variesBy-, atau productGroupID-spesifik konten. Bing’s Shopping variant grouping runs melalui sebuah feed-side itemGroupId field di Microsoft Advertising — analog dari Google’s item_group_id, not pada-halaman schema. So: implement ProductGroup untuk Google, dan handle Bing Shopping variants melalui Microsoft Advertising feed, not markup.

sebuah note pada 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.” (terjemahan) “menjadi aware itu dynamically-generated markup dapat membuat Shopping melakukan crawl less frequent dan less reliable, which dapat menjadi sebuah issue untuk fast-changing konten like product availability dan price.” jika Anda variant offers/availability adalah JS-injected, weigh itu terhadap server-rendering markup untuk fields itu perubahan sering.

Validate sebelum Anda ship

• Rich hasil Test — memeriksa eligibility dan surfaces diperlukan-property errors untuk merchant-listing/variant experience.
• Schema Markup Validator (schema.org) — validates ProductGroup/Product jenis themselves, independent dari Google fitur.
• Search Console — merchant-listings/product-snippet enhancement reports tampilkan eligibility dan errors di scale post-deploy; pemeriksaan URL menampilkan how sebuah spesifik halaman adalah read.

Remember what “valid” (terjemahan) “valid” melakukan dan doesn’t tell Anda: sebuah plain-string variesBy passes validation dan, di my testing, masih doesn’t trigger grouping. Validation catches syntax dan diperlukan-property gaps, not ini jenis dari semantic failure (which Google doesn’t document either cara) — untuk itu, periksa oleh hand itu Anda variesBy nilai adalah full URLs dan Anda productGroupID matches di seluruh group.

untuk where ini fits bigger picture, see broader data terstruktur dan schema markup hubs ini artikel lives di bawah.

AI summary

sebuah condensed take pada Advanced versi:

• What ini adalah: ProductGroup (Google, Feb 2024) wraps variant Product objects di bawah one parent so Google understands “same item, different options” (terjemahan) “sama item, berbeda options” alih-alih unrelated products. Eligibility untuk variant display di merchant listings — not sebuah peringkat factor.
• Additive, not sebuah replacement: setiap variant stays sebuah full Product (sku/gtin, offers, image, availability); ProductGroup adalah wrapper dan isn’t sold pada -nya own (no single price pada group).
• Three core properties: hasVariant nests variants (atau isVariantOf poin back up); variesBy lists varying axes dan harus gunakan full schema.org URLs (https://schema.org/color, not "color") — #1 implementation mistake, dan dalam praktik (not something Google documents) ini validates fine while grouping quietly doesn’t trigger; productGroupID adalah sebuah plain text parent sku (not sebuah URL, e.g. "44E01"), dan jika set pada both group dan variants nilai harus match — Google documents match aturan tetapi not what happens pada sebuah mismatch.
• Two patterns: nested (hasVariant, single-halaman situs, one canonical URL untuk group) vs. flat (isVariantOf + inProductGroupWithID, multi-halaman situs, full self-berisi markup per halaman). Variants perlu unique sku/gtin dan sebuah distinct preselectable URL.
• diperlukan vs. recommended: hanya name adalah diperlukan; variesBy + productGroupID adalah functionally essential bahkan though technically recommended.
• productGroupID ≠ item_group_id: pada-halaman schema (pencarian organik) vs. Merchant Center feed attribute (Shopping/free listings) — separate sistem, nothing auto-syncs, gunakan matching nilai pada purpose.
• Bing doesn’t mendukung ProductGroup (Fabrice Canel, Sept 2024, via mesin pencari Roundtable). Bing Shopping variants run melalui Microsoft Advertising’s feed-side itemGroupId, not markup.
• Watch dynamic markup (less reliable Shopping melakukan crawl untuk price/availability). Validate dengan Rich hasil Test + schema.org Validator, tetapi remember plain-string variesBy validates dan masih fails.

Official documentation

Primary-source documentation untuk ProductGroup dan variant markup.

Google

• Product variant data terstruktur (ProductGroup, Product) — single authoritative halaman: ProductGroup, hasVariant, isVariantOf, variesBy, productGroupID, full schema.org URL aturan, diperlukan/recommended properties, dan single-halaman vs. multi-halaman aturan.
• menambahkan data terstruktur mendukung untuk Product Variants (Feb 2024 blog) — announcement itu introduced properties.
• Intro untuk Product data terstruktur — umum Product halaman (Product snippets / merchant listings). Note: ini melakukan not cover ProductGroup — itu’s separate halaman above.
• Google Merchant Center — Item group ID [item_group_id] — product-feed attribute untuk grouping variants, dan -nya schema.org cross-references.

Bing / Microsoft

• Bing Webmaster alat — Marking up Anda situs dengan data terstruktur — sebuah generic overview dari didukung formats; no ProductGroup-, variesBy-, atau productGroupID-spesifik konten.

schema.org

• schema.org/ProductGroup — vocabulary halaman: authoritative property list dan Product/Thing inheritance (no implementation contoh atau Google-spesifik guidance).

Quotes dari source

pada—record statements dari Google (dan reported statements dari Microsoft). Where sebuah halaman exposes text, tautan adalah sebuah deep tautan itu jumps untuk quoted passage.

Google docs — purpose dan 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.” (terjemahan) “untuk help Google better memahami which products adalah variations dari yang sama parent product, gunakan ProductGroup class dengan associated properties variesBy, hasVariant, dan productGroupID untuk group such variants together.” Jump untuk 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).” (terjemahan) “banyak jenis dari products such sebagai apparel, shoes, furniture, electronic devices, dan luggage adalah sold di berbeda variations (misalnya various sizes, colors, materials, atau patterns).” Jump untuk quote
• “Adding this markup also makes your products eligible for display with variant information in merchant listing experiences.” (terjemahan) “menambahkan ini markup juga membuat Anda products eligible untuk display dengan variant informasi di merchant listing experiences.” Jump untuk quote

Google docs — properties

• variesBy: “Aspects by which the variants in the ProductGroup vary… Reference these variant-identifying properties through their full Schema.org URL.” (terjemahan) “Aspects oleh which variants di ProductGroup vary… Reference ini variant-identifying properties melalui mereka full Schema.org URL.” Jump untuk 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.” (terjemahan) “sebuah nested Product property itu adalah one dari variants dari ProductGroup property, jika applicable. sebuah ProductGroup typically memiliki multiple nested variant Product properties.” Jump untuk quote
• isVariantOf: “Alternatively, a variant Product property can reference back to its parent ProductGroup using the isVariantOf property on the Product property.” (terjemahan) “Alternatively, sebuah variant Product property dapat reference back untuk -nya parent ProductGroup menggunakan isVariantOf property pada Product property.” Jump untuk 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.” (terjemahan) “ identifier dari product group (juga known sebagai parent sku). ini identifier harus menjadi disediakan untuk ProductGroup property atau, alternatively, menggunakan inProductGroupWithID property untuk variants.” Jump untuk quote
• pada matching IDs: “If you provide the identifier for both the ProductGroup property and its variant Product properties, they must match.” (terjemahan) “jika Anda menyediakan identifier untuk both ProductGroup property dan -nya variant Product properties, mereka harus match.” Jump untuk quote

Google docs — unique IDs dan URLs

• “Each variant must have a unique ID in its corresponding structured data markup (for example, using the sku or gtin properties).” (terjemahan) “setiap variant harus memiliki sebuah unique ID di -nya corresponding data terstruktur markup (misalnya, menggunakan sku atau gtin properties).” Jump untuk quote
• “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.” (terjemahan) “ situs harus memiliki ability untuk preselect setiap variant directly dengan sebuah distinct URL (menggunakan URL kueri parameters), misalnya undefined” Jump untuk quote
• pada 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.” (terjemahan) “menjadi aware itu dynamically-generated markup dapat membuat Shopping melakukan crawl less frequent dan less reliable, which dapat menjadi sebuah issue untuk fast-changing konten like product availability dan price.” Jump untuk quote

Google Merchant Center — item_group_id

• “Use the item group ID [item_group_id] attribute to group product variants in your product data.” (terjemahan) “gunakan item group ID [item_group_id] attribute untuk group product variants di Anda product data.” Jump untuk quote

John Mueller, Google (via mesin pencari Roundtable’s verbatim reproduction dari 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 Results Testing tool and in the Search Console reports for these types.” (terjemahan) “Product variants di ecommerce adalah complicated - what melakukan Anda melakukan dengan t-shirts di berbeda colors? Folks here Google worked hard untuk come up dengan data terstruktur markup & mendukung untuk ini… perubahan adalah juga live di Rich hasil Testing alat dan di Search Console reports untuk ini jenis.” Read coverage

Fabrice Canel, Microsoft Bing (reported, not sebuah pertama-party doc)

• Responding untuk whether Bing mendukung schema.org/ProductGroup, Canel said Bing melakukan not yet mendukung ini, tetapi itu ini adalah “on our radar” (terjemahan) “pada kami radar” dan team adalah “closely monitoring its adoption.” (terjemahan) “closely monitoring -nya adoption.” Coverage Relayed via mesin pencari Roundtable’s coverage dari sebuah September 2024 exchange pada X; sebuah secondary report dari sebuah pertama-party statement, not sebuah Microsoft documentation halaman.

sebuah complete ProductGroup JSON-LD contoh

Google’s own doc contoh adalah intentionally minimal — one variant, no offers. Here’s sebuah fuller, single-halaman (nested hasVariant) versi dengan two variants, offers, gtin, image, dan brand — shape Anda’d actually ship. Note variesBy menggunakan full schema.org URLs, dan productGroupID adalah sebuah 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 untuk notice:

• ProductGroup memiliki no offers/price dari -nya own — price lives pada setiap variant’s Offer, because group isn’t sebuah single sellable thing.
• setiap variant carries sebuah unique sku (dan here sebuah gtin), -nya own image, -nya own availability, dan size/color nilai itu match what variesBy declared.
• Availability adalah per-variant — kecil green coat adalah InStock, besar blue one OutOfStock. itu’s correct cara untuk handle sebuah partially-stocked group (see out-dari-stock products guide untuk cara signal ini without dropping variant).

multi-halaman (flat) variant dari yang sama setup

jika setiap variant lives pada -nya own URL, Anda tidak nest — setiap halaman carries -nya own self-berisi Product itu poin back up dengan isVariantOf dan 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"
  }
}

setiap variant halaman repeats ini pattern dengan -nya own IDs dan offer, dan yang sama productGroupID ("44E01") ties them together. pertahankan itu ID identical di seluruh semua variant halaman dan aligned dengan Anda Merchant Center item_group_id.

seharusnya Anda gunakan ProductGroup, dan which pattern?

Walk tree untuk land pada right markup decision untuk Anda setup.

umum ProductGroup mistakes

traps, dan what’s actually benar:

ProductGroup implementation checklist

berfungsi melalui ini di order — setiap item maps untuk sebuah spesifik gotcha covered above.

• Decide Anda pattern pertama. semua variants selectable pada one URL → nested (hasVariant). setiap variant pada -nya own URL → flat (isVariantOf + inProductGroupWithID). Don’t mix patterns pada yang sama group.
• pertahankan setiap variant sebuah full Product. setiap one masih memiliki -nya own sku/gtin, image, offers, dan availability — ProductGroup tidak pernah carries sebuah single price dari -nya own.
• Write variesBy sebagai full schema.org URLs, e.g. https://schema.org/color dan https://schema.org/size — not "color" / "size". ini adalah #1 implementation mistake; ini validates either cara, dan grouping quietly doesn’t trigger without URL form di my testing (not something Google documents), so periksa ini oleh eye.
• Set productGroupID sebagai sebuah plain-text identifier (parent sku, e.g. "44E01") — tidak pernah sebuah URL. berbeda aturan dari variesBy; don’t conflate them.
• Match productGroupID (atau inProductGroupWithID) di seluruh setiap variant. Google documents match requirement tetapi not what happens jika ini adalah violated; di my testing, sebuah typo pada one variant halaman drops ini dari group dengan no error.
• Give setiap variant sebuah unique ID via sku atau gtin.
• Confirm setiap variant memiliki sebuah distinct, preselectable URL (kueri params adalah fine, e.g. ?size=small&color=green). sebuah JS-hanya state perubahan dengan no URL dapat’t menjadi validated atau terindeks sebagai -nya own variant.
• Align productGroupID dengan Merchant Center’s item_group_id. mereka’re separate sistem dan nothing auto-syncs them — gunakan yang sama nilai pada purpose.
• server-render fast-changing fields (price, availability) where mungkin — Google warns dynamically-generated markup dapat membuat Shopping melakukan crawl less frequent dan reliable.
• Validate, lalu verify oleh hand. Run Rich hasil Test dan schema.org Validator — lalu manually re-periksa variesBy URLs dan productGroupID matching, since both pass validation bahkan when broken.
• jika Anda juga target Bing, don’t rely pada ProductGroup — ini isn’t consumed di semua (per Microsoft’s Fabrice Canel, Sept 2024). Handle Bing Shopping variants melalui Microsoft Advertising’s feed-side itemGroupId instead.

ProductGroup quick-reference

productGroupID vs. item_group_id vs. inProductGroupWithID

Nothing auto-syncs ini di seluruh sistem — gunakan sama nilai di semua three so organic dan Shopping agree pada which SKUs belong together.

Nested vs. flat pattern

Property format aturan

Catch #1 implementation mistake: variesBy sebagai plain strings

variesBy nilai itu skip full schema.org URL prefix adalah single sebagian besar umum mistake di ini topic — JSON-LD masih validates, so nothing errors out, dan di my testing grouping quietly doesn’t trigger (Google’s docs memerlukan full-URL form tetapi don’t document what happens jika Anda skip ini). ini snippets catch ini directly alih-alih relying pada eyeballing markup.

Regex: flag sebuah buruk variesBy array di raw JSON-LD

Run ini di atas extracted JSON-LD source (e.g. sebuah Screaming Frog custom extraction export, atau apa pun raw HTML/text dump) untuk temukan variesBy arrays containing sebuah nilai itu isn’t sebuah full schema.org URL:

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

• "variesBy"\s*:\s*\[ — matches start dari property dan -nya opening bracket, allowing untuk whitespace formatting differences.
• (?:"(?!https://schema\.org/)[^"]*"\s*,?\s*)+ — capture group: matches one atau more quoted strings where sebuah negative lookahead (?!https://schema\.org/) aturan out anything itu sudah starts dengan correct prefix. jika ini group matches anything di semua, setidaknya one entry di array adalah sebuah buruk plain string like "color" atau "size" alih-alih sebuah full URL.
• sebuah match berarti: stop dan fix itu array sebelum shipping — ini akan validate clean dan masih fail untuk trigger grouping.

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

Paste ke Console pada apa pun halaman Anda expect untuk carry ProductGroup markup. ini pulls setiap JSON-LD block, walks ke ProductGroup objects (including ones nested di bawah isVariantOf), dan reports apa pun variesBy entry itu isn’t sebuah 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 untuk Screaming Frog: extract productGroupID di seluruh variant halaman

gunakan custom extraction untuk pull productGroupID nilai straight out dari JSON-LD script tag, lalu compare extracted nilai di seluruh Anda di-crawl variant URLs untuk spot sebuah mismatch:

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

Extract full text dari setiap matching node, lalu periksa extracted productGroupID (dan inProductGroupWithID pada flat/multi-halaman setups) adalah identical di seluruh setiap URL itu’s supposed untuk belong untuk yang sama group — sebuah single differing nilai berarti itu halaman memiliki mungkin dropped out dari group dengan no error thrown, berdasarkan testing (Google’s docs memerlukan match tetapi don’t document mismatch perilaku).

Test yourself: ProductGroup Schema

Five quick pertanyaan pada ProductGroup, -nya core properties, dan gotchas. Pick sebuah jawaban untuk setiap, lalu periksa.

Resources worth Anda time

My related writing

I haven’t published sebuah piece specifically pada ProductGroup schema — ini artikel adalah dedicated treatment. closest adjacent things I’ve written itu inform ini:

• Google menggunakan ~40 Canonicalization Signals — Here’s What itu berarti — “keep your signals consistent” (terjemahan) “pertahankan signals consistent” discipline itu underpins matching productGroupID di seluruh variants (dan aligning ini dengan item_group_id).
• Myth dari Duplicate konten Penalty (mesin pencari Land) — why grouping variants sebagai one item di options, alih-alih fearing them sebagai duplicates, adalah right mental model. There’s no duplicate-konten penalty untuk “fix” (terjemahan) “fix” dengan ProductGroup — ini adalah tentang understanding, not avoiding sebuah fine.

untuk strategy layer — whether sebuah variant seharusnya bahkan get -nya own URL, dan how Shopify/WooCommerce/BigCommerce/Magento differ — see product variant SEO guide pada ini situs. untuk fundamentals, schema markup dan data terstruktur hubs, dan sibling Product schema deep dive.

dari sekitar industry

• Product variant data terstruktur (Google Search Central) — authoritative reference; read ini alongside ini untuk full property tables.
• menambahkan data terstruktur mendukung untuk Product Variants (Google Search Central blog) — Feb 2024 announcement.
• Item group ID [item_group_id] (Google Merchant Center Help) — feed-side attribute dan -nya schema.org cross-references.
• baru Google Search mendukung untuk Product Variant data terstruktur (mesin pencari Roundtable) — Feb 2024 launch recap, dengan John Mueller’s verbatim LinkedIn post.
• Bing melakukan not mendukung ProductGroup markup (mesin pencari Roundtable) — Fabrice Canel statement (Sept 2024).
• Google menambahkan mendukung untuk product variants (mesin pencari Land) — sama-day announcement coverage.
• Google untuk Display More Product Variants dengan baru Markup (mesin pencari Journal) — SEJ take pada launch.
• Schema piece: ProductGroup (Yoast Developer Portal) — nyata JSON-LD contoh dan Yoast’s default productGroupID-dari-SKU perilaku (plugin-spesifik).
• cara implement ProductGroup schema (Go Fish Digital) — plain-English “why this exists” (terjemahan) “why ini exists” framing.
• schema.org/ProductGroup — vocabulary itself, straight dari source.

Log perubahan