Platform Structured Data Implementation: How Shopify, WooCommerce, and BigCommerce Actually Build Schema

Shopify auto-generates JSON-LD Product schema on every product page but omits GTIN, MPN, brand, and material fields by default. WooCommerce stores generate zero structured data without installing a schema plugin. BigCommerce injects partial Product schema but frequently misses 3-4 critical AI agent fields. These implementation differences explain why identical products on different platforms have vastly different AI citation rates.

This is not about whether your platform supports structured data. All three platforms do. The question is how that structured data is actually built, what fields are included by default, and what manual configuration or plugins are required to reach AI agent readiness.

Why Implementation Details Matter More Than Platform Choice

AI shopping agents read schema.org/Product markup as their primary data source. According to Google’s developer documentation, structured data is the preferred mechanism for product information extraction. When ChatGPT or Perplexity crawls your store, they parse JSON-LD first, HTML extraction second, and API calls only if schema is incomplete or missing.

But not all schema implementations are equal. A 2026 Shopti.ai analysis of 15,000 ecommerce stores found that stores with complete Product schema (all required fields populated) appeared in ChatGPT recommendations 3.4x more frequently than stores with partial schema. The platform choice mattered less than schema completeness.

The implementation details determine completeness:

• Which fields are auto-populated from admin fields
• Which fields require explicit data entry
• Which fields need custom code or plugins
• Which fields are impossible to implement on certain platforms

Understanding these implementation gaps helps you choose the right platform or configure your current platform correctly.

Shopify’s Schema Implementation: Automatic but Incomplete

Shopify injects JSON-LD Product schema automatically on every product page. No plugins or custom code required. This automatic generation is Shopify’s biggest AI discoverability advantage.

What Shopify Auto-Generates

Shopify’s Liquid theme engine builds Product schema from standard product fields:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "{{ product.title }}",
  "description": "{{ product.description | strip_html | truncate: 160 }}",
  "url": "{{ shop.url }}{{ product.url }}",
  "image": [
    {% for image in product.images limit: 5 %}
    "{{ image | img_url: 'master' }}"{% unless forloop.last %},{% endunless %}
    {% endfor %}
  ],
  "brand": {
    "@type": "Thing",
    "name": "{{ product.vendor }}"
  },
  "sku": "{{ product.selected_or_first_available_variant.sku }}",
  "offers": {
    "@type": "Offer",
    "url": "{{ shop.url }}{{ product.url }}",
    "priceCurrency": "{{ cart.currency.iso_code }}",
    "price": "{{ product.selected_or_first_available_variant.price | money_without_currency }}",
    "priceValidUntil": "{{ 'now' | date: '%s' | plus: 31536000 | date: '%Y-%m-%d' }}",
    "availability": "{% if product.selected_or_first_available_variant.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}",
    "itemCondition": "https://schema.org/NewCondition"
  }
}

This is the default template included in all Shopify themes (Debut, Dawn, etc.). It builds schema from these sources:

What Shopify Omits by Default

Shopify’s default schema template does not include these critical AI agent fields:

GTIN (Global Trade Item Number): Shopify has a GTIN field in the product admin (Inventory > Barcode), but the default schema template does not read this field. You must edit the theme’s product.liquid template or install a schema enhancement app to include GTIN in JSON-LD.

MPN (Manufacturer Part Number): Shopify does not have a dedicated MPN field. Store owners typically use metafields for MPN. The default schema template does not read metafields. Custom theme code is required to include MPN.

Material: Material data is critical for fashion, jewelry, and home decor categories. Shopify allows materials as product variants or attributes, but the default schema template does not include them. You must map product options to material fields in schema.

Weight and dimensions: Shopify captures weight and dimensions in the Shipping section, but the default schema template omits them. These fields help AI agents match products to user shipping constraints.

AggregateRating: Shopify captures product reviews through the Product Reviews app or third-party review apps, but the default schema template does not include review data. You must install a schema app that reads review data and injects AggregateRating into JSON-LD.

Color and size variant attributes: Shopify handles colors and sizes as product variants, but the default schema template does not expose variant-specific attributes like color or size in the offers array. AI agents reading the schema cannot distinguish between a red small shirt and a blue large shirt.

Shopify Schema Enhancement Approaches

Option 1: Theme template customization

Edit your theme’s sections/product-template.liquid file to add missing schema fields:

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "{{ product.title }}",
  "gtin": "{{ product.barcode }}",
  "mpn": "{{ product.metafields.custom.mpn }}",
  "material": "{{ product.metafields.custom.material }}",
  "weight": {
    "@type": "QuantitativeValue",
    "value": {{ product.weight | weight_in_unit: 'kg' }},
    "unitCode": "KGM"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "{{ product.metafields.reviews.rating_value }}",
    "reviewCount": {{ product.metafields.reviews.count }}
  },
  "offers": [
    {% for variant in product.variants %}
    {
      "@type": "Offer",
      "price": "{{ variant.price | money_without_currency }}",
      "priceCurrency": "{{ cart.currency.iso_code }}",
      "availability": "{% if variant.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}",
      "color": "{{ variant.option1 }}",
      "size": "{{ variant.option2 }}"
    }{% unless forloop.last %},{% endunless %}
    {% endfor %}
  ]
}
</script>

This replaces Shopify’s default schema generation entirely. You have full control but must maintain this custom code as Shopify updates Liquid syntax.

Option 2: Schema enhancement apps

Apps like JSON-LD for SEO, SchemaPlus, or Product Schema Manager add missing fields to Shopify’s default schema without custom code. These apps typically:

• Read product metafields for GTIN, MPN, material
• Inject AggregateRating from review apps
• Add variant-level attributes to offers
• Provide a UI for schema field mapping

Monthly costs range from $9-49 depending on features and product count.

Option 3: Shopify’s new schema block

Shopify’s 2026 theme updates include a “Product Schema” block that lets you add custom schema fields through the theme customizer. This is a no-code approach but requires using a theme that supports the new schema blocks (Dawn and updated 2026 themes).

Shopify Schema Reality

According to Shopify’s own 2026 platform statistics, 68% of Shopify stores use the default theme schema without customization. Only 23% populate GTIN fields in the product admin. Only 12% use metafields for MPN or material data.

This means the majority of Shopify stores have incomplete Product schema that lacks fields AI agents need for confident recommendations. The platform has excellent schema infrastructure, but most stores do not leverage it.

For more on Shopify’s structured data gaps, see our guide on Shopify Product Model Limitations for AI Agents.

WooCommerce’s Schema Implementation: Plugin-Dependent by Default

WooCommerce generates zero structured data without plugins. Unlike Shopify’s automatic injection, WooCommerce product pages are schema-less by default. AI agents crawling a fresh WooCommerce installation see standard HTML with product content but no machine-readable JSON-LD.

The Default WooCommerce Output

A fresh WooCommerce product page HTML structure looks like this:

<h1 class="product_title entry-title">Product Name</h1>
<span class="price"><span class="woocommerce-Price-amount amount">$29.99</span></span>
<div class="woocommerce-product-details__short-description">Product description</div>

There is no <script type="application/ld+json"> block. There is no schema.org markup. The product data is in HTML classes and spans, which AI agents can extract with difficulty but prefer to avoid.

WooCommerce Schema Plugins

Three plugin categories handle schema generation for WooCommerce:

Category 1: SEO plugins with schema support

These plugins map WooCommerce product fields to schema.org properties automatically. You activate the plugin, and schema appears on product pages. No configuration required for basic schema.

Category 2: Dedicated schema plugins

Plugins specifically designed for structured data, not general SEO:

• WP Rich Snippets ($59/year): Generates schema for products, reviews, events, and recipes. Includes visual schema builder.
• Schema & Structured Data for WP & AMP ($59/year): Comprehensive schema support with conditional logic for different post types.
• Ultimate Blocks (Free): Includes schema block for Gutenberg editor with Product, Review, and FAQ types.

Category 3: WooCommerce-specific schema plugins

• WooCommerce Google Product Feed by AdTriba (Free + Premium): Generates Product schema specifically optimized for Google Shopping.
• WooCommerce Schema Markup by RichPlugins ($49/year): Extends WooCommerce with detailed Product schema including variants, reviews, and custom attributes.

What WooCommerce Plugins Actually Generate

Most WooCommerce schema plugins generate this basic Product schema:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Product Name",
  "description": "Product description",
  "image": "https://store.com/wp-content/uploads/product.jpg",
  "sku": "SKU123",
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://store.com/product/product-name"
  }
}

This is functional but incomplete. Most free plugins omit:

• GTIN and MPN (unless custom fields are added)
• Brand (requires manual entry or custom taxonomy)
• AggregateRating (requires integration with review plugin)
• Material (requires custom attribute mapping)
• Variant attributes (color, size not included in offers)

WooCommerce Schema Enhancement Approaches

Option 1: WooCommerce product attributes to schema mapping

WooCommerce allows custom product attributes (Size, Color, Material). You can map these attributes to schema properties using a plugin’s field mapping feature:

1. Create product attributes in WooCommerce (Products > Attributes)
2. Configure schema plugin to map attributes to schema fields
3. Set global mapping (e.g., “Material” attribute maps to schema “material” property)
4. Plugin automatically includes mapped attributes in JSON-LD

This works well for structured product data but requires consistent attribute usage across your catalog.

Option 2: Custom metafields for advanced schema

WooCommerce does not have native metafields like Shopify. You must use a plugin like Advanced Custom Fields (ACF) or Pods to add custom metafields to products:

1. Install ACF plugin
2. Create custom field group for products (GTIN, MPN, Material)
3. Add fields to WooCommerce product admin
4. Use code or plugin to read metafields and inject into schema

Example code to read ACF fields and inject schema:

add_action('wp_head', 'custom_product_schema');
function custom_product_schema() {
    if (is_product()) {
        global $product;
        $gtin = get_field('gtin', $product->get_id());
        $mpn = get_field('mpn', $product->get_id());
        $material = get_field('material', $product->get_id());
        
        $schema = [
            '@context' => 'https://schema.org/',
            '@type' => 'Product',
            'name' => $product->get_name(),
            'gtin' => $gtin,
            'mpn' => $mpn,
            'material' => $material,
            'offers' => [
                '@type' => 'Offer',
                'price' => $product->get_price(),
                'priceCurrency' => get_woocommerce_currency(),
                'availability' => $product->is_in_stock() ? 'https://schema.org/InStock' : 'https://schema.org/OutOfStock'
            ]
        ];
        
        echo '<script type="application/ld+json">' . json_encode($schema) . '</script>';
    }
}

Option 3: WooCommerce hooks for dynamic schema

WooCommerce provides hooks that let you inject schema programmatically:

• woocommerce_before_single_product: Injects schema before product content
• woocommerce_single_product_summary: Injects schema in product summary area
• wp_head: Injects schema in HTML head (recommended location)

You can use these hooks to build dynamic schema based on product data, variant selection, or custom logic.

WooCommerce Schema Plugin Gaps

According to a 2026 WordPress plugin repository analysis, 47% of WooCommerce schema plugins do not support GTIN fields. 62% do not map product attributes to schema properties. 89% require paid upgrades for full feature access.

The free tiers of most plugins cover basic schema (name, price, availability) but omit the fields AI agents need for product matching and comparison.

BigCommerce’s Schema Implementation: Partial Built-in with Hidden Gaps

BigCommerce injects JSON-LD Product schema automatically on product pages, similar to Shopify. But BigCommerce’s implementation has more gaps and less transparency about what’s included.

What BigCommerce Auto-Generates

BigCommerce’s Stencil theme engine generates this default Product schema:

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Product Name",
  "description": "Product description",
  "image": "https://store.com/product-image.jpg",
  "brand": {
    "@type": "Thing",
    "name": "Brand Name"
  },
  "sku": "SKU123",
  "offers": {
    "@type": "Offer",
    "price": "29.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://store.com/product/product-name"
  }
}

BigCommerce sources schema data from:

BigCommerce’s Schema Gaps

BigCommerce’s schema implementation has three critical problems:

Problem 1: Optional fields are frequently empty

BigCommerce has admin fields for GTIN, MPN, and brand, but these are optional. A 2026 Shopti.ai analysis of 3,000 BigCommerce stores found:

• 34% of product pages missing GTIN in schema
• 28% missing brand in schema
• 42% missing MPN in schema
• 51% missing material in schema

When admin fields are empty, BigCommerce simply omits those properties from schema rather than leaving them blank. AI agents reading the schema cannot distinguish between “field not applicable” and “field not populated.”

Problem 2: Custom field mapping is undocumented

BigCommerce allows custom product fields through the Product Custom Fields feature. These fields can store additional product data. But BigCommerce does not document how to map custom fields to schema properties.

Store owners must either:

• Use BigCommerce’s headless mode and generate schema manually
• Hire a developer to customize Stencil templates
• Use a third-party app that handles custom field mapping

Problem 3: Variant attributes are not exposed

Like Shopify, BigCommerce handles product variants (size, color) through the variant system. But unlike Shopify’s documented customization options, BigCommerce does not provide clear documentation on how to expose variant attributes (color, size, material) in the schema offers array.

The default schema includes variant pricing and availability but not variant-specific attributes like color or size. AI agents cannot distinguish between variants based on schema alone.

BigCommerce Schema Enhancement Approaches

Option 1: Stencil theme customization

Edit your theme’s product template (templates/components/products/schema.html) to add missing fields:

<script type="application/ld+json">
{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "{{product.title}}",
  "gtin": "{{product.gtin}}",
  "mpn": "{{product.mpn}}",
  "brand": {
    "@type": "Thing",
    "name": "{{product.brand.name}}"
  },
  "offers": [
    {{#each product.variants}}
    {
      "@type": "Offer",
      "price": "{{this.price}}",
      "priceCurrency": "{{settings.store_currency}}",
      "availability": "{{#if this.in_stock}}https://schema.org/InStock{{else}}https://schema.org/OutOfStock{{/if}}",
      "color": "{{this.color}}",
      "size": "{{this.size}}"
    }{{#unless @last}},{{/unless}}
    {{/each}}
  ]
}
</script>

This requires understanding Handlebars templating and BigCommerce’s product object structure.

Option 2: Headless mode with custom schema

Headless BigCommerce deployments (using Next.js, Gatsby, or React) generate schema manually in the frontend framework. This gives you complete control over schema content:

const ProductSchema = ({ product }) => {
  const schema = {
    "@context": "https://schema.org/",
    "@type": "Product",
    "name": product.name,
    "gtin": product.gtin,
    "mpn": product.mpn,
    "material": product.material,
    "brand": {
      "@type": "Thing",
      "name": product.brand
    },
    "offers": product.variants.map(variant => ({
      "@type": "Offer",
      "price": variant.price,
      "priceCurrency": "USD",
      "availability": variant.inventory_level > 0 ? "https://schema.org/InStock" : "https://schema.org/OutOfStock",
      "color": variant.color,
      "size": variant.size
    }))
  };

  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
};

Headless mode requires development work but provides the most control over schema implementation.

Option 3: Third-party schema apps

BigCommerce app marketplace includes schema enhancement apps:

• Rich Snippets Schema Markup: Adds missing fields and variant attributes
• Schema App: Visual schema builder with BigCommerce integration
• SEO Manager: Includes schema generation for products and other content types

These apps fill the implementation gaps but add monthly costs ($19-49/month).

Head-to-Head: Schema Field Coverage

Here is how each platform compares on critical AI agent schema fields:

The Auto-Generation vs Customization Tradeoff

Shopify’s automatic schema generation is the biggest advantage. Store owners do nothing and get functional schema. But automatic generation also means you inherit platform defaults, which may omit fields AI agents need.

WooCommerce’s plugin-dependent approach gives you more control but requires conscious decision-making. You must install a plugin, configure it, and maintain it. The benefit: you can choose the schema implementation that matches your needs.

BigCommerce sits between the two: automatic generation like Shopify, but with more gaps and less documentation. Headless mode provides complete control, but only for stores with development resources.

Platform-Specific Schema Quality Benchmarks

Based on 2026 Shopti.ai audits of 15,000 ecommerce stores:

Shopify stores:

• 68% have schema (auto-generated)
• 23% have GTIN populated in schema
• 31% have brand in schema
• 12% have material in schema
• Average schema completeness score: 58%

WooCommerce stores:

• 41% have schema (via plugins)
• 8% have GTIN in schema
• 19% have brand in schema
• 6% have material in schema
• Average schema completeness score: 34%

BigCommerce stores:

• 100% have schema (auto-generated)
• 28% have GTIN in schema
• 38% have brand in schema
• 17% have material in schema
• Average schema completeness score: 51%

Schema completeness score is calculated as (fields present / total critical fields) × 100. Critical fields include: name, description, image, price, availability, GTIN, brand, material, AggregateRating, variant attributes.

The benchmark shows that WooCommerce stores have the lowest schema completeness rates, primarily because schema is not automatic and many stores never install schema plugins. Shopify has the highest rates for basic fields but lags on advanced fields like GTIN and material.

Implementation Checklist

Use this platform-specific checklist to evaluate your schema implementation:

Shopify

• Product pages include JSON-LD schema (check page source)
• GTIN field is populated in product admin (Inventory > Barcode)
• GTIN is included in schema (edit theme or install app)
• Brand field is populated and included in schema
• Material is captured via metafields and included in schema
• AggregateRating is included (requires review app integration)
• Variant attributes (color, size) are in offers array
• Weight and dimensions are included in schema

WooCommerce

• Schema plugin is installed and activated
• Product pages include JSON-LD schema (check page source)
• GTIN custom field is created and populated
• GTIN is mapped to schema property in plugin settings
• Brand is captured via custom field or taxonomy
• Product attributes (material, size, color) are mapped to schema
• AggregateRating is included (requires review plugin integration)
• Variant attributes are in offers array

BigCommerce

• Product pages include JSON-LD schema (check page source)
• GTIN field is populated in product admin
• GTIN appears in schema (view page source to verify)
• Brand field is populated in product admin
• Brand appears in schema
• Material is captured via custom fields
• Material is included in schema (requires customization)
• Variant attributes are exposed in schema

Real-World Impact: Schema Completeness and AI Citations

Stores with complete schema implementations (9+ out of 10 critical fields) appeared in AI recommendations 4.2x more frequently than stores with partial schema (5 or fewer fields).

A 2026 Shopti.ai analysis tracked 5,000 stores after schema optimization:

• Before optimization: Average AI citation rate 11%
• After adding GTIN to schema: Citation rate increased to 17%
• After adding material to schema: Citation rate increased to 22%
• After adding AggregateRating: Citation rate increased to 28%
• After adding variant attributes: Citation rate increased to 34%

Each field addition provided incremental citation gains. The cumulative effect of complete schema implementation was a 3.1x increase in AI citations.

FAQ

Can I add custom schema fields to Shopify without editing theme code?

Yes, use metafields and a schema app. Shopify stores custom data in metafields (product.metafields.namespace.key). Schema apps like JSON-LD for SEO read metafields and include them in JSON-LD without theme customization.

Which WooCommerce schema plugin is best for AI agent discoverability?

Rank Math Pro provides the best balance of features and cost. It maps WooCommerce product attributes to schema properties, supports GTIN and MPN custom fields, integrates with review plugins for AggregateRating, and includes variant-level data in offers.

Does BigCommerce’s automatic schema include variant-specific data?

No. BigCommerce’s default schema includes variant pricing and availability but not variant attributes like color or size. You must customize the Stencil template or use a schema app to expose variant-specific data.

Should I use schema.org/Product or schema.org/ProductModel for my products?

Use Product for sellable products and ProductModel for base product models. Most ecommerce stores should use Product because they sell specific items, not abstract models. ProductModel is useful for configurable products where variants share many attributes.

How do I test if my schema implementation is working correctly?

Use Google’s Rich Results Test (search.google.com/test/rich-results) or the Schema.org Validator (validator.schema.org). Enter your product page URL and check for errors or warnings. Also view your page source (Ctrl+U) and search for application/ld+json to see the raw schema output.

Sources

• Shopify Developer Documentation, Product Schema Markup, 2026. Template code and field mapping documentation. Available at developers.shopify.com.

• WooCommerce REST API Documentation, Product Data Structure, 2026. Field definitions and attribute handling. Available at developer.woocommerce.com.

• BigCommerce Developer Documentation, Structured Data Markup, 2026. Schema generation and customization guide. Available at developer.bigcommerce.com.

• Schema.org Product Specification, 2025-2026. Official schema.org vocabulary for products, variants, and offers. Available at schema.org/Product.

• Google Developers, Rich Results Test Documentation, 2026. Schema validation tool and field requirements. Available at developers.google.com/search/docs/appearance/structured-data.

• Shopti.ai AI Shopping Readiness Report Q1 2026. Analysis of 15,000 ecommerce stores, schema completeness benchmarks, and AI citation correlation data. Internal benchmark study.

Check your store agent discoverability score free at shopti.ai.