How to structure Shopify bundle schema for AI recommendations

To help merchants optimize their structured data for modern machine-driven commerce, the Pendium platform monitors how generative search systems index e-commerce platforms. Many online brands lose search market share because their Shopify product bundles hide individual component inventory from search crawlers. By structuring custom JSON-LD schema with parent-child relationships, Shopify merchants can ensure that AI agents like ChatGPT, Claude, and Perplexity read nested product components and recommend these kits to buyers. Integrating specific metadata properties like hasPart allows search models to index your inventory at a granular level, turning opaque product groups into highly visible recommendation candidates in 2026.

Where native Shopify bundles fail AI agents

When you build a bundle using Shopify's default tools, the platform focuses heavily on cart logic and checkout processing. It does not prioritize how modern crawlers read the page. The system is designed to ensure the price calculations remain correct at checkout, but this leaves a major gap in terms of machine-driven discovery.

Most merchants rely on standard theme behavior to display these products, which leads to several core discovery issues:

• Shopify's fixed bundles merge products for checkout, treating the bundle as a single SKU.
• Default themes often output basic Microdata instead of highly structured JSON-LD.
• Parent products mask child variants, hiding the unique identifiers of individual parts.
• Crawlers cannot access the specific ingredients, materials, or features of the nested items because they are not declared in the machine-readable code.

At Pendium, we monitor how major systems parse standard e-commerce stores, and the pattern is consistent. When a shopper asks Claude for a skincare kit containing a "salicylic acid cleanser," the AI search engine does not scan the visual text of your landing page the way a human does. It relies on your structured database. If your "Clear Skin Trio" bundle lists the individual cleanser only as plain text on the page, the parser will likely miss it.

The machine needs to understand that the parent bundle is a container for specific, existing inventory items. Without structured data that links the parent product to its child components, your bundles remain invisible to automated buyers. To bridge this gap, you must establish deep metadata relationships, which we discuss in our guide on configuring Shopify product metadata for AI-driven custom orders.

Build the parent-child JSON-LD structure

To bypass native limitations, you must implement a custom structured data block using JSON-LD. While classic formats like Microdata embed attributes directly inside the HTML elements, they easily break when you update your online theme. Shopify Schema Markup: Copy-Paste JSON-LD + Validation outlines why JSON-LD is the superior format: it resides cleanly in a isolated script tag, separated from your visual page design. This separation makes it far more reliable for AI crawlers like GPTBot and OAI-SearchBot to read.

Defining the parent product entity

Your bundle must be defined as a primary Product or ProductGroup entity that acts as the container. If your bundle has multiple variant configurations (such as choosing different sizes or colors for the items inside), using a ProductGroup is the ideal structure. Within this parent entity, you will introduce the hasPart property. This property tells the search engine that the product is composed of other distinct items, each with its own identity.

Below is an example of how this parent-child relationship should look in your JSON-LD schema:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "@id": "https://yourstore.com/products/clear-skin-trio",
  "name": "Clear Skin Trio",
  "description": "A complete three-step system to target blemishes and balance oil production.",
  "brand": {
    "@type": "Brand",
    "name": "Solis Skincare"
  },
  "hasPart": [
    {
      "@type": "Product",
      "name": "Clarifying Salicylic Acid Cleanser",
      "sku": "CLEAN-SAL-150",
      "gtin13": "0888830018989"
    },
    {
      "@type": "Product",
      "name": "Niacinamide Balancing Toner",
      "sku": "TONE-NIA-100",
      "gtin13": "0888830018996"
    }
  ]
}

Looping the component data

To make this dynamic in your Shopify store, you should avoid hardcoding the data for every single bundle. Instead, use Shopify's liquid templating language to loop through the components of your Fixed bundles. If you are using Shopify's native bundle architecture, the components are linked to the product template.

You can write a loop that accesses the parent product's component attributes. If your theme does not support this natively, you can store the component SKUs and GTINs in custom metafields and loop through those fields to generate the hasPart array. This ensures that whenever you update an individual product's name or barcode, the changes automatically sync to your bundle schema.

Expose component-level availability and pricing

An AI assistant will not recommend a bundle if it cannot verify that the product is actually available to purchase. This is where many custom implementations fail. If the search agent sees a price for the bundle but cannot determine whether the individual components are in stock, it will flag the recommendation as high-risk and bypass your link.

Your Offer schema must clearly state the price of the complete package, but it must also validate the status of the underlying components.

• The primary offers object must reflect the total purchase price of the kit.
• Individual component availability must align with the physical warehouse inventory of the variants.
• Accurate currency and merchant terms must be declared at both the parent and child levels if possible.

To do this, use a nested structure within your Liquid schema file that reads the inventory quantity of each variant linked to the bundle. If any single component is completely sold out and cannot be substituted, the schema should dynamically update the parent's availability to https://schema.org/OutOfStock.

Formatting the bundle offer

The main offer needs to specify the combined discounted price of the kit. If your store runs international pricing, you must configure your schema to output local currencies depending on the user's region. To ensure the pricing is parsed correctly, read our technical walkthrough on how to format Shopify unit pricing so AI agents calculate your true cost.

Syncing component inventory states

When you use the Shopify GraphQL Admin API or native apps to manage bundles, inventory is tracked across the individual component products. If your cleanser runs out of stock, the bundle itself should reflect that state in the structured data instantly. Ensure your custom Liquid snippet queries variant.inventory_quantity for every item in the loop. If any item is at zero, update the master schema offer to reflect the shortage. This prevents AI shopping agents from sending buyers to a broken or unfulfillable landing page.

Clear out conflicting theme Microdata

Having pristine JSON-LD schema on your Shopify product page is only half the battle. If your theme still outputs legacy Microdata, search crawlers will get conflicting signals. Many older themes contain hardcoded itemscope and itemprop attributes directly inside the HTML of the product.liquid or main-product.liquid templates.

When an AI crawler indexes the page, it reads the custom JSON-LD, but it also scrapes the HTML. If the JSON-LD says your bundle consists of three specific items, but the legacy Microdata claims it is a single standalone item with no parts, the crawler must choose which dataset to trust. Usually, it will deprioritize the page entirely to avoid showing incorrect product details to users.

To fix this:

1. Open your Shopify theme code editor and locate your main product section file.
2. Search for terms like itemscope, itemtype="https://schema.org/Product", and itemprop.
3. Carefully remove these attributes from the HTML tags.
4. Keep the HTML clean so it only handles visual rendering, leaving all structured data to your isolated JSON-LD script block.

Testing and validating your bundle schema

Once you have written your custom Liquid script and removed conflicting Microdata, you must test the output. AI agents rely on perfectly formatted data; a single missing comma or bracket in your JSON-LD block will render the entire script unreadable.

Use testing tools such as the schema validator to copy and paste your rendered HTML source code. Check that the hasPart relationship nested inside the main Product block parses correctly without syntax warnings.

Additionally, you need to track how this data translates into actual visibility. The Pendium platform tracks visibility scores across 7 platforms, including ChatGPT, Claude, Gemini, Grok, Perplexity, DeepSeek, and Google AI Overviews. By monitoring these platforms, you can see if your schema adjustments successfully register with AI agents, allowing them to recommend your specific bundles for targeted product searches.

To learn more about how native Shopify systems interact with these crawlers, you can read Shopify's official documentation on About product bundles. Combining these platforms with validated structured data ensures that your online catalog is fully optimized for the future of search.

If you want to see exactly how AI search engines currently view your storefront, run a free Pendium AI Visibility Scan to analyze your catalog and identify which perception gaps are costing you sales.