Zum Hauptinhalt springen
🇩🇪

Product-Schema-Beispiel für Shopify-Apparel

Sofort kopierbare JSON-LD Product- und ProductGroup-Schema-Beispiele für Shopify-Apparel — Größen- und Farbvarianten, Offers, Breadcrumbs und die AggregateRating-Regeln, die entscheiden, ob KI-Suchmaschinen deine Produktseite tatsächlich zitieren.

4 min read

Apparel-Produktseiten auf Shopify werden von KI-Shopping-Engines zitiert, je nachdem, wie präzise das JSON-LD die Variantenlandschaft beschreibt. Ein Käufer, der auf ChatGPT, Perplexity oder Gemini nach „Leinenhemd, das in Medium echt sitzt“ fragt, braucht eine KI, die erkennt: diese spezifische Variante existiert, ist auf Lager, hat einen Preis und ist unterscheidbar von den L- und XL-Geschwistern. Generisches Product-Schema ohne Varianten-Detail zwingt die KI zum Raten; ProductGroup mit hasVariant gibt ihr die Daten zum selbstbewussten Zitieren.

Dieses Beispiel liefert zwei kopierfertige JSON-LD-Blöcke: ein ProductGroup für die Variantenmatrix und ein BreadcrumbList für Kategoriekontext. Beide sind so kalibriert, dass sie Google Rich Results Test sauber durchlaufen und den sichtbaren Seiteninhalt spiegeln (die Regel, die KI-Engines in der Praxis tatsächlich durchsetzen).

Wann Product vs ProductGroup

Use caseSchemaWarum
Einzel-SKU-Item (eine Größe, eine Farbe)ProductKeine Variantenmatrix — ProductGroup ist Overkill.
Apparel mit nur GrößenvariantenProductGroup + variesBy: sizeKI-Shopping-Queries sind größenkonditioniert; flaches Product verliert das.
Apparel mit nur FarbvariantenProductGroup + variesBy: colorKI-Queries sind farbkonditioniert.
Apparel mit Größe × Farbe MatrixProductGroup + beide variesByKartesisches Produkt der Varianten; jedes hasVariant ist die eindeutige SKU.
Bundle / Kit (mehrere Eltern)Pro Item Product + custom isRelatedToProductGroup beschreibt Produktvarianten, keine Multi-Produkt-Bundles.

Shopifys Standard-Liquid-Templates emittieren Product unabhängig von der Variantenanzahl. Das Upgrade auf ProductGroup für jeden Apparel- Store mit mehreren Größen ist eine einmalige Theme-Anpassung (oder eine Shopify-App, die das automatisch erledigt); der KI-Shopping-Citation- Lift ist die Mühe wert.

ProductGroup-JSON-LD (Apparel mit Varianten)

In ein Produktseiten-Template einfügen und die Platzhalterwerte ersetzen. Das Beispiel zeigt einen 2-Varianten-Auszug; in Produktion hast du einen hasVariant-Eintrag pro reale SKU.

ProductGroup-JSON-LD (Apparel-Varianten) json
{
  "@context": "https://schema.org",
  "@type": "ProductGroup",
  "name": "Linen Relaxed Shirt",
  "description": "A breathable linen shirt in three colors, sizes XS–XL. 100% European linen, pre-washed for softness.",
  "brand": {
    "@type": "Brand",
    "name": "Example Apparel"
  },
  "productGroupID": "linen-shirt-001",
  "variesBy": ["https://schema.org/size", "https://schema.org/color"],
  "hasVariant": [
    {
      "@type": "Product",
      "sku": "LINEN-SHIRT-WHITE-M",
      "name": "Linen Relaxed Shirt — White / M",
      "color": "White",
      "size": "M",
      "material": "Linen",
      "image": "https://example.com/products/linen-shirt-white.jpg",
      "offers": {
        "@type": "Offer",
        "url": "https://example.com/products/linen-shirt?variant=white-m",
        "priceCurrency": "USD",
        "price": "79.00",
        "availability": "https://schema.org/InStock",
        "itemCondition": "https://schema.org/NewCondition"
      }
    },
    {
      "@type": "Product",
      "sku": "LINEN-SHIRT-BLACK-S",
      "name": "Linen Relaxed Shirt — Black / S",
      "color": "Black",
      "size": "S",
      "material": "Linen",
      "image": "https://example.com/products/linen-shirt-black.jpg",
      "offers": {
        "@type": "Offer",
        "url": "https://example.com/products/linen-shirt?variant=black-s",
        "priceCurrency": "USD",
        "price": "79.00",
        "availability": "https://schema.org/InStock",
        "itemCondition": "https://schema.org/NewCondition"
      }
    }
  ]
}

Die ProductGroup mit einem BreadcrumbList paaren, damit KI-Engines verstehen, in welcher Kategorie dein Produkt lebt. Die Breadcrumb-URLs müssen exakt mit dem sichtbaren Breadcrumb der Seite übereinstimmen.

BreadcrumbList-JSON-LD json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Shirts",
      "item": "https://example.com/collections/shirts"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Linen Relaxed Shirt",
      "item": "https://example.com/products/linen-shirt"
    }
  ]
}

Häufige Fehler (nach Häufigkeit sortiert)

  1. Varianten markupen, die auf der Seite nicht sichtbar oder auswählbar sind. Schema muss sichtbare Realität spiegeln. Wenn deine Produktseite nur S / M / L zeigt, aber JSON-LD XS bis XXL deklariert, versuchen KI-Engines irgendwann, eine Variante zu zitieren, die 404 ist, und downweighten den Store.

  2. AggregateRating verwenden, wenn kein Review-Widget existiert. Entweder die Reviews sichtbar zeigen (Shopify-Reviews-App nutzen) oder das Schema-Feld weglassen. Nicht erfinden.

  3. Inkonsistenz von Currency, Preis oder Verfügbarkeit zwischen Schema und sichtbarer Produktseite. Käufer sieht $79, aber Schema deklariert 89.00 — KI-Engines greifen die Schema-Zahl auf, zitieren sie, und der Käufer fühlt sich getäuscht. Schlimmer noch: Google flaggt das Schema als unzuverlässig.

  4. Dieselbe sku für mehrere Varianten verwenden. Shopify generiert eindeutige SKUs, aber Merchants überschreiben sie oft. Doppelte SKUs in hasVariant führen dazu, dass KI-Engines Varianten falsch zusammenführen.

  5. ProductGroup und Product so mischen, dass variantenspezifische Namen verloren gehen. Wenn du sowohl Product als auch ProductGroup für dasselbe Item emittierst, stelle sicher, dass die Product-Instanz das Eltern-Element ist (kein Varianten- Detail), und ProductGroup.hasVariant die Varianten enthält. Nicht Product für jede Variante außerhalb der Group emittieren.

  6. Medizinische oder unbelegte Claims in Apparel-Beschreibungen. „Haltungskorrigierend“ / „verbessert die Durchblutung“ / „antibakterielle Faser verhindert Hautkrankheiten“ — das sind in den meisten Märkten regulierte Claims und triggern KI-Engine- Downweighting selbst wenn rechtlich OK. Bei Passform- und Materialbeschreibungen bleiben.

  7. Schema-URLs auf nicht-kanonische Varianten-URLs zeigen lassen. Wenn die Seite eine kanonische Produkt-URL nutzt (z.B. /products/linen-shirt) und Varianten per Query-Param ausgewählt werden (?variant=white-m), sollte hasVariant[].offers.url trotzdem auf die variantenspezifische URL zeigen — dort landen Käufer (und KI-Agents).

Wie validieren

  1. Die deployte Produkt-URL bei

    Google Rich Results Test

    einfügen. Product- und BreadcrumbList-Item sollten beide validieren.
  2. Die Validierungs-Checkliste oben Feld für Feld durchgehen.
  3. Die Seite im Inkognito-Fenster öffnen und prüfen, dass sichtbare Produkt-H1, Preis, Verfügbarkeit und Breadcrumb alle mit dem Schema übereinstimmen.
  4. Bei Strukturänderungen (neue Farbe, gestrichene Größe) den Schema-Generator neu laufen lassen und redeployen.

JSON-LD ist ein Signal im KI-Shopping-Stack. Paare es mit der Fashion-llms.txt-Vorlage für die Inhaltskarte-Seite und prüfe mit dem Robots-Analyzer, dass GPTBot die Produktseite erreichen kann.

Validierungs-Checkliste

  • Produktname im Schema stimmt mit der sichtbaren H1 überein

    Das `name`-Feld der ProductGroup stimmt exakt mit der H1 auf der Produktseite überein (Groß-/Kleinschreibung und Zeichensetzung). KI-Engines downweighten Mismatches als Low-Trust-Signal.

  • Jede Variante hat eine eindeutige SKU

    Keine zwei `hasVariant[].sku`-Werte kollidieren. Shopify erzeugt SKUs automatisch, aber Merchants überschreiben sie oft — doppelte SKUs im Schema führen dazu, dass KI-Engines Varianten falsch zusammenführen.

  • Variantennamen benennen Größe / Farbe / Material

    Jeder `hasVariant[].name` liest sich wie ein echtes Produktlabel (z.B. „Linen Relaxed Shirt — White / M“), kein Platzhalter. KI-Shopping-Antworten zitieren dieses Feld direkt.

  • productGroupID ist deployübergreifend stabil

    Die `productGroupID` sollte ein stabiler interner Identifikator sein (Shopify-Product-GID oder ein eigener Slug), keine zufällige Build-Time-UUID. KI-Engines nutzen sie zur Deduplizierung desselben Produkts über Page-Reloads hinweg.

  • Jedes Offer hat Currency + Price + Availability + URL

    Jeder Variant-`offers`-Block hat `priceCurrency`, `price`, `availability` und `url`. Fehlende Currency ist Grund Nr. 1, warum Google Rich Results Test ein Product-Result herabstuft.

  • AggregateRating nur vorhanden, wenn echte Reviews sichtbar sind

    Wenn du `aggregateRating` ausgibst, müssen Rating + Review-Count sichtbar auf der Produktseite stehen. KI-Engines vergleichen Schema mit sichtbarem Inhalt; fabrizierte Ratings triggern Downweighting.

  • BreadcrumbList stimmt mit dem sichtbaren Breadcrumb überein

    Die `itemListElement`-URL-Kette stimmt exakt mit dem sichtbaren Breadcrumb der Seite überein (gleicher Pfad, gleiche Labels). Abweichungen verwirren KI-Engines, die Breadcrumb-Kontext für Kategorieverständnis nutzen.

  • Rich Results Test liefert keine kritischen Fehler

    Nach dem Deploy die Produkt-URL bei https://search.google.com/test/rich-results einfügen — Product- und BreadcrumbList-Item sollten beide ohne kritische Fehler validieren.

Im Schema-Generator öffnen

Vorausgefüllt mit Apparel-Store-Platzhaltern für Produktname, Beschreibung, Brand, Preis, Verfügbarkeit und Ratings. Platzhalter durch echte Produktdaten ersetzen und einen Shopify-fertigen JSON-LD-Block herunterladen.

Häufig gestellte Fragen

Soll ein Shopify-Apparel-Produkt Product oder ProductGroup verwenden?

Verwende `Product` für ein einfaches Item ohne Varianten. Verwende `ProductGroup`, sobald Größen-, Farb- oder Materialvarianten existieren — es erlaubt KI-Engines, die richtige Variante für eine spezifische Query („Leinenhemd in Größe M“) zu zitieren, statt sie zu verschmelzen. Shopify-Standard-Liquid-Templates emittieren nur `Product`; das Upgrade auf `ProductGroup` ist manuell, aber für jeden Apparel-Store mit mehreren Größen die Mühe wert.

Darf ich AggregateRating ausgeben, ohne dass Reviews auf der Seite sichtbar sind?

Nein. Schema muss sichtbaren Inhalt spiegeln. Wenn du `aggregateRating: 4.7 from 32 reviews` ausgibst, aber die Produktseite kein Review-Widget zeigt, flaggen sowohl KI-Engines als auch Google das als unzuverlässig. Entweder die Reviews sichtbar rendern (Shopify-Apps wie Judge.me oder native Shopify Reviews) oder das Schema-Feld komplett weglassen.

Soll jede Farbvariante ein eigener hasVariant-Eintrag sein?

Ja, wenn die Variante eigene SKU, Farbe, Größe, Bild, Preis oder Verfügbarkeit hat. KI-Shopping-Engines, die „ist das schwarze Leinenhemd noch verfügbar“ beantworten, brauchen jede Variante als eigenständig adressierbaren Product-Node mit eigenem `offers.availability`. Nur Farbe → ein `hasVariant` pro Farbe; nur Größe → einer pro Größe; Größe + Farbe → kartesisches Produkt.

Ersetzt ProductGroup-Schema die Shopify-Produkt-Feeds?

Nein. JSON-LD auf der Seite ergänzt Feeds (Shopifys auto-generierte `/products.json`, Google Merchant Feed, Meta Catalog). KI-Shopping-Engines crawlen Seiten direkt *und* lesen Feeds — beide Signale zählen. Lass keins zugunsten des anderen weg.

Verwandte Ressourcen