How to fix duplicate Shopify JSON-LD before AI engines drop your products

When Shopify themes and third-party apps both output Product schema, AI shopping agents get confused. Here is how to find and remove duplicate JSON-LD.

When Shopify themes and third-party apps independently output JSON-LD, they create conflicting records of the same item. For an AI visibility platform like Pendium, monitoring product discovery across ChatGPT and Gemini reveals that this duplication forces language models to guess which price, review score, or availability state is accurate. The fix requires testing the rendered DOM with structured data diagnostic tools to identify the redundant entity, then either removing the schema code directly from main-product.liquid or injecting a footer script that suppresses the default Dawn theme markup so your dedicated application serves as the single source of truth.

The schema collision problem in AI recommendation systems

Online merchants install review widgets and optimization tools to win rich snippets, but this often introduces competing data blocks behind the scenes. When a customer lands on your storefront, your product page looks visually coherent. Under the hood, your source code might deliver two or three disconnected @type: "Product" definitions for a single URL.

Traditional search engines spent over a decade writing heuristics to stitch messy structured data together. When Google detects two conflicting blocks, it attempts to merge them or defaults to the block with the most complete fields. AI shopping agents—the autonomous crawlers powering conversational search in ChatGPT, Claude, Perplexity, and Gemini—do not work with that forgiveness. These platforms parse raw text and JSON-LD to answer buyer prompts directly.

When an AI engine processes a page with contradictory markup, it encounters an entity resolution error:

The default theme markup reports 0 reviews because it cannot read dynamic app data.
A third-party review tool injects a separate schema block reporting 140 reviews with a 4.9-star rating.
An SEO app injects a third block that lists the base product price but omits current variant inventory.

Faced with this ambiguity, an AI assistant does not spend compute cycles guessing which block represents reality. Instead, the model flags the listing as unreliable and excludes it from comparison answers. Store managers who notice their category positions slipping can scan your AI visibility to determine whether contradictory machine-readable markup is steering shoppers toward competitor catalogs. As analyzed in technical audits of Shopify duplicate schema, uncoordinated JSON-LD injections routinely strip stores of their algorithmic search trust.

Why your store generates multiple product records

The root cause of schema duplication sits within the architecture of Shopify itself. The platform relies on isolated applications that operate in functional silos. Themes, review platforms, and metadata plugins execute code independently, with no native protocol to verify whether structured data already exists before rendering their own payload.

The default theme payload

Modern Online Store 2.0 themes, including Dawn, Symmetry, and their derivatives, ship with built-in structured data. Theme developers hardcode JSON-LD blocks into liquid templates like sections/main-product.liquid or snippet files like snippets/product-media-gallery.liquid.

These templates pull directly from Shopify's internal liquid objects (product.title, product.price, product.description). This baseline schema works well for an unmodded store, but it rarely accounts for external data. Native templates cannot automatically pull review counts from third-party databases, nor can they handle specialized inventory policies without complex custom liquid development.

The third-party app injection

To display review stars or custom product properties, merchants turn to the Shopify App Store. When you install an application for ratings or metadata optimization, the app must make that data legible to machines.

Some well-engineered tools check theme settings or hook directly into Shopify app blocks. Many others, however, simply append a fresh, standalone <script type="application/ld+json"> payload to the document <head> or <body>. Review apps frequently bundle an entire new Product object alongside their AggregateRating properties. When an SEO utility also injects its own structured data, the page ends up with three competing definitions of the same commercial asset. As documented in community reports on the Dawn theme duplicate structured data conflict, these disconnected injections break search validation across the catalog.

The technical sequence to fix duplicate markup

Resolving structured data conflicts requires isolating the duplicate source, determining which system carries the most complete product data, and eliminating redundant blocks.

Follow this sequence to clear conflicting schema from your product pages:

Test your product URL in a validation tool to list all distinct Product entities.
Inspect the raw page source to identify which block belongs to your theme and which belongs to your apps.
Decide which markup source will serve as your canonical graph.
Strip the theme markup manually through the liquid code or suppress it using a targeted script.
Re-validate the live page to confirm only one unified Product entity remains.

Identify the source using Google testing tools

Start by loading a representative product URL into Google's Rich Results Test or the Schema.org Validator. Look at the detected items pane. If you see multiple separate "Product" cards rather than a single nested hierarchy, your store is running duplicate schema.

Next, open the product page in your browser, right-click, and select "View Page Source." Use your browser's search feature to find application/ld+json. Scan through each JSON block to locate @type": "Product".

Apps like Booster SEO or Avada SEO Suite often wrap their output in identifying HTML comment tags. A comment reading  or  tells you immediately where that markup originates. A schema block that sits lower down in the source without identifying comments is almost always generated by your theme's liquid files, as outlined in discussions on removing duplicate schema.

Option A: Remove the theme schema manually

If you use a dedicated SEO application to manage structured data, the cleanest fix is to remove the native theme markup entirely. This prevents the theme from writing empty or conflicting properties to the page.

From your Shopify admin, go to Online Store > Themes.
Find your current theme, click the three dots, and select Edit code.
In the left-hand search bar, look for main-product.liquid (or check snippets/product-schema.liquid depending on your theme build).
Search inside the file for <script type="application/ld+json">.
Identify the block that outputs the Product schema. In Dawn-based themes, this script typically wraps a liquid loop containing "@type": "Product", product.name, and offers.
Comment out the block using liquid comment tags:

{% comment %}
<script type="application/ld+json">
  {
    "@context": "http://schema.org/",
    "@type": "Product",
    "name": {{ product.title | json }},
    ...
  }
</script>
{% endcomment %}

Save your changes and refresh your product page to verify that the theme block no longer renders in the DOM.

Option B: Use a JavaScript removal snippet

Some premium themes, such as Symmetry, spread schema logic across multiple encrypted or complex section files, making manual file edits risky during future theme updates. When direct code deletion is impractical, you can remove the theme markup dynamically in the browser.

Because most third-party SEO applications inject their schema into the document <head>, while theme templates render their JSON-LD within the <body>, you can instruct the browser to strip body-level schema before search bots complete parsing. In community resolutions addressing Avada SEO Suite and Symmetry conflicts, merchants resolved severe duplication by adding a targeted script to their theme.liquid footer:

<script>
  document.addEventListener("DOMContentLoaded", function() {
    var bodySchemas = document.querySelectorAll('body script[type="application/ld+json"]');
    bodySchemas.forEach(function(schema) {
      if (schema.textContent.includes('"@type":"Product"') || schema.textContent.includes('"@type": "Product"')) {
        schema.remove();
      }
    });
  });
</script>

This snippet locates JSON-LD elements rendered inside the body tags that contain product definitions and removes them from the DOM, leaving the app's clean <head> schema as the sole reference for search agents.

Signs the schema conflict is severe

Duplicate markup issues are invisible on your storefront, but they leave distinct diagnostic footprints. When apps clash, the symptoms appear in developer tools, search console dashboards, and AI retrieval results.

Watch for these warning signs across your product catalog:

Google Search Console displays "Multiple items detected" warnings within the Product Snippets and Merchant Listings enhancement tabs.
Your testing tools show one complete schema block alongside a broken block that throws warnings for missing price, sku, or availability attributes.
Conversational AI assistants give incorrect pricing or claim your products are out of stock when responding to user comparison queries.
The source code reveals three or more separate <script type="application/ld+json"> tags containing @type: "Product".

To understand how conflicting blocks confuse automated bots, compare how different tools report the same physical item:

Structured Data Source	Injected Location	Price Accuracy	Variant Coverage	Review Signals	AI Interpretation Risk
Shopify Dawn Theme	Document Body	Current base price	First variant only	Omitted or 0 reviews	Model assumes product has no social proof
Review App (e.g. Yotpo)	Document Head	Often hardcoded/stale	Missing variant data	Complete aggregate rating	Model reads rating but finds invalid pricing
Third-Party SEO App	Document Head	Synchronized with feed	Full multi-variant graph	Pulls from review API	Ideal single source of truth

When these blocks sit on the same page without connecting @id nodes, an AI crawler cannot determine whether it is reading one product with multiple attributes or three different items sharing a single URL. This confusion is particularly damaging for stores managing complex inventory rules. For instance, catalog misalignments can cause automated buyers to assume stock is unavailable, a problem explored in our analysis of why AI shopping agents say your Shopify pre-orders are sold out. Eliminating contradictory records restores confidence in your core product attributes.

Keeping your structured data clean

Fixing your theme once does not protect your store permanently. E-commerce teams frequently add merchandising tools, review importers, and loyalty programs to drive conversions. Each new application risks reintroducing rogue JSON-LD into your product pages.

Maintaining clean structured data requires treating your schema as a singular data pipeline. Pick one system to govern product entities. If you use a dedicated SEO app, turn off schema injection settings inside your review apps, affiliate tools, and loyalty widgets. Most modern review applications provide a toggle in their settings menu labeled "Inject rich snippets" or "Add schema markup." Switch that setting off so the app only renders front-end widgets, allowing your primary schema engine to query the review API and nest the AggregateRating object inside the main Product block.

Whenever you update your theme or test a new marketing plugin, review your rendered DOM. Use the AI Site Audit tool to verify that AI crawlers can parse your schema, hierarchy, and business details without running into conflicting entities. Routine auditing ensures your technical foundation remains stable as AI agents play a larger role in consumer purchasing decisions.

Audit your store for conversational search

When an AI shopping agent scans your catalog, contradictory schema forces it to make assumptions about your prices, ratings, and availability. To see how autonomous crawlers evaluate your product pages and determine if technical conflicts are suppressing your listings in conversational search, see your visibility scan preview and secure your product recommendations across every major AI platform.