Shopify GA4 Tracking Broken? How Mismatched Item Names Kill Your Conversion Data

Your ads team says conversions are missing. Shopify shows sales every day, but GA4 reports a 0% conversion rate. The Whatagraph dashboard is empty. The Google Ads manager is confused. Everyone is pointing fingers.

I see this exact scenario on at least one out of every three Shopify stores I audit. The root cause is almost never a missing tracking tag. It is almost always a data consistency problem that nobody thought to check.

This post walks through the most common reasons Shopify GA4 ecommerce tracking breaks silently, using a real case study from a DTC water bottle brand where mismatched item_name values destroyed months of conversion data.

The Problem: GA4 Cannot Connect Events With Different Item Names

GA4 ecommerce tracking relies on a set of sequential events to build a conversion funnel: view_item, add_to_cart, begin_checkout, and purchase. For GA4 to connect these events into a coherent user journey, the items array parameters must be consistent across all four events.

The most critical parameter is item_name.

If a user views a product and GA4 records the item_name as “Sips Water Bottle”, but the add_to_cart event records it as “Candy” (the variant color), GA4 treats these as two completely unrelated products. The funnel breaks. Attribution breaks. Your conversion data becomes meaningless.

This is not a bug in GA4. It is working exactly as designed. GA4 uses item_name and item_id as the primary keys for matching ecommerce events across the funnel. Change either value between events, and GA4 has no way to know they refer to the same product.

Case Study: A DTC Water Bottle Brand With Zero Reported Conversions

A DTC water bottle brand hired me to figure out why their GA4 showed zero ecommerce conversions despite Shopify recording consistent daily sales. Their ads team was pulling reports through Whatagraph and seeing nothing, even though Meta was driving over 1,000% more clicks month-over-month.

What I Found

The store’s theme contained a custom storefront-tracking.liquid snippet, 397 lines of JavaScript that pushed GA4 ecommerce events to the dataLayer via Google Tag Manager.

Here is what the view_item event push looked like (simplified):

dataLayer.push({
  event: "view_item",
  ecommerce: {
    items: [{
      item_name: {{ product.title | json }},
      item_id: {{ product.id | json }},
      price: {{ product.price | divided_by: 100.0 }},
      item_variant: {{ product.selected_or_first_available_variant.title | json }}
    }]
  }
});

This correctly used product.title, so the item_name value was the full product name, something like “Sips.TM - Water Bottle”.

But the add_to_cart and purchase events were not fired by this same snippet. They were fired by a separate GTM tag that pulled item data from Shopify’s native checkout data layer, which used the variant title as the item name. So the purchase event looked like this:

// What the purchase event actually sent
{
  event: "purchase",
  ecommerce: {
    items: [{
      item_name: "Candy",  // This is the variant color, not the product title
      item_id: "gid://shopify/ProductVariant/12345678",
      price: "34.95"
    }]
  }
}

GA4 received a view_item for “Sips.TM - Water Bottle” and a purchase for “Candy”. It had no way to connect these. Every single conversion was orphaned.

The Debug Flag Problem

On top of the item name mismatch, the tracking snippet had CONFIG.debug set to true:

var CONFIG = {
  debug: true,
  // ... other settings
};

This meant every single visitor on every single page load triggered verbose console logging of all dataLayer pushes. Not a performance catastrophe on its own, but unnecessary JavaScript execution on a production store that nobody was actively debugging. It also leaked the entire tracking implementation to anyone who opened browser DevTools.

The Reporting Chain Reaction

Here is how one mismatched parameter cascaded through the entire reporting stack:

1. GA4 Ecommerce Reports - Zero conversions attributed to any product. Funnel visualization showed users viewing products but never purchasing, even though they were.
2. Google Ads - The Ads manager confirmed that conversions were tracked via a native Google Ads tag through GTM, not imported from GA4. This meant the same dataLayer inconsistency affected both GA4 and Google Ads conversion tracking.
3. Whatagraph - Pulled data from GA4, so it inherited the zero-conversion problem. The ads team saw empty dashboards and assumed Meta campaigns were not converting.
4. Business decisions - The team was about to cut Meta ad spend based on data that was completely wrong.

The Fix

The fix was straightforward once the root cause was identified:

1. Audit the GTM Container

I exported the GTM container and mapped every tag that fired an ecommerce event. This revealed three separate sources of ecommerce data:

• The custom storefront-tracking.liquid snippet (view_item, select_item)
• A GTM tag using Shopify’s checkout data (add_to_cart, begin_checkout, purchase)
• Shopify’s native Web Pixel (duplicate of everything above)

2. Standardize item_name Across All Events

Every ecommerce event must use the same item_name value. I updated the GTM tags for add_to_cart, begin_checkout, and purchase to pull the product title consistently:

// Standardized item mapping for all ecommerce events
function getItemData(product, variant) {
  return {
    item_name: product.title,           // Always the full product title
    item_id: product.id.toString(),     // Consistent ID format
    item_variant: variant.title,        // Variant info goes here, not in item_name
    price: parseFloat((variant.price / 100).toFixed(2)),
    item_brand: product.vendor,
    quantity: 1
  };
}

The key principle: item_name is the product title. item_variant is where variant-specific information like color or size belongs. GA4’s ecommerce schema was designed this way intentionally.

3. Disable Duplicate Event Sources

I disabled Shopify’s native Web Pixel for GA4 since GTM was already handling all events. Running both causes duplicate page_view, view_item, and purchase events, which inflates every metric downstream.

4. Turn Off Debug Mode

var CONFIG = {
  debug: false,
  // ...
};

Simple but often overlooked. I have audited stores where debug mode has been running in production for over a year.

5. Validate With GA4 DebugView

After deploying the fixes, I used GA4 DebugView to walk through the full funnel on a test device:

1. View a product page, confirm view_item fires with item_name: "Sips.TM - Water Bottle"
2. Add to cart, confirm add_to_cart fires with the same item_name
3. Begin checkout, confirm begin_checkout matches
4. Complete purchase, confirm purchase matches

All four events now carried identical item_name and item_id values. GA4 could finally stitch the funnel together.

Other Common Shopify GA4 Tracking Issues

The item name mismatch is the most damaging issue I encounter, but it is rarely the only one. Here are three other problems I find on nearly every Shopify store audit.

Duplicate Event Firing From Theme Code and Shopify Native Pixel

Shopify’s Web Pixels API was introduced to give app developers and merchants a standardized way to fire analytics events. The problem is that many stores already had GTM-based tracking in their theme code before Web Pixels existed.

When both systems run simultaneously, GA4 receives two of every event. Your session count doubles. Your conversion rate gets cut in half (same conversions, double the sessions). Your ecommerce funnel shows impossible numbers.

The fix: pick one system and disable the other. If you need granular control over ecommerce parameters (which you do if you care about item_name consistency), use GTM and disable the native pixel. Go to Settings > Customer events in your Shopify admin and remove or pause the GA4 pixel.

Web Pixel Sandbox Generating Phantom Sessions

Shopify’s Web Pixels run inside a sandboxed iframe. This sandbox has its own execution context, which means it can generate its own page_view events with a separate client ID. GA4 interprets this as a new session.

The result is inflated session counts with abnormally low engagement rates. You will see sessions with 0 seconds engagement time and zero events beyond page_view. These phantom sessions dilute every rate-based metric in your reports: conversion rate, engagement rate, bounce rate.

If you see a suspiciously high number of sessions with zero engagement, check whether you have a Web Pixel running alongside theme-based tracking. The sandbox is almost certainly the source.

Bot Traffic Inflating Session Counts

GA4’s built-in bot filtering catches known bots, but it misses a significant portion of automated traffic. On one store I audited, 47% of total sessions were bots, identified by cross-referencing GA4 data with Microsoft Clarity session recordings.

The bot sessions shared common patterns:

• Zero mouse movement
• Zero scroll depth
• Sub-second visit duration
• No interaction events beyond page_view
• Concentrated bursts from specific geographic regions

Clarity’s session recordings made it obvious. When you watch a “session” that loads the page and immediately leaves with no human interaction, that is a bot. GA4 alone will not tell you this.

Install Microsoft Clarity on every store. It is free, it takes five minutes to set up, and it gives you the ground truth that GA4 cannot provide on its own. I cover analytics setup in more detail in my Shopify CRO audit checklist.

How to Audit Your Shopify GA4 Tracking Right Now

You do not need to hire someone to check if your tracking is broken. Here is a quick self-audit:

Step 1: Check Event Consistency in GA4 DebugView

1. Open GA4 and go to Admin > DebugView
2. Install the GA4 Debugger Chrome extension
3. Visit a product page on your store and click the view_item event in DebugView
4. Note the item_name value
5. Add the product to cart and check the add_to_cart event
6. Compare the item_name values

If they differ, your funnel is broken.

Step 2: Check for Duplicate Events

In DebugView, watch for duplicate events firing within milliseconds of each other. If you see two page_view events or two view_item events on a single page load, you have duplicate tracking sources.

Step 3: Check Your Conversion Source in Google Ads

In Google Ads, go to Tools > Conversions > Summary. Click on your purchase conversion action and check the Source. If it says “Google Analytics 4” and your GA4 data is broken, your Ads optimization is running on bad data. If it says “Website” with a Google Ads tag, the Ads tag may have its own item name issues.

Step 4: Review Session Quality in Clarity

Look at Clarity’s dashboard for these red flags:

• Scroll depth below 10% on a large percentage of sessions
• Dead click rate near zero (real users always have some dead clicks)
• Session duration clustering at under 1 second

Any of these patterns suggest bot traffic inflating your GA4 numbers.

Prevention: What to Require in Every GTM Setup

If you are working with a developer or agency on your GTM implementation, require these as non-negotiable deliverables:

1. A single source of truth for ecommerce events. Either GTM or Shopify’s native pixel. Never both.
2. Consistent item parameters across all events. Document the exact values for item_name, item_id, item_brand, and item_variant and verify they match across view_item, add_to_cart, begin_checkout, and purchase.
3. Debug mode off in production. Any CONFIG.debug, console.log, or verbose logging should be gated behind a query parameter or cookie, not a hardcoded boolean.
4. A documented data layer specification. Every event, every parameter, every expected value. If your GTM setup does not have documentation, it will break the moment anyone touches the theme.
5. Quarterly validation. Shopify updates its checkout, themes update their JavaScript, and apps inject their own tracking. What worked three months ago may be broken today.

For a broader framework on auditing your entire Shopify conversion funnel beyond just analytics, read my complete CRO audit guide.

Conclusion

Broken Shopify GA4 tracking rarely announces itself. There is no error message, no alert, no red banner in your dashboard. Your store keeps selling. Your ads keep running. The only signal is a quiet mismatch between what Shopify reports and what GA4 shows, and most teams either do not notice or assume GA4 is “just inaccurate.”

It is not inaccurate. It is working with the data you give it. If your view_item says the product is “Sips.TM - Water Bottle” and your purchase says it is “Candy”, GA4 will faithfully report that nobody who viewed that water bottle ever bought anything. And your team will make real budget decisions based on that fictional data.

Audit your tracking before your next campaign. It takes 30 minutes to verify and could save months of misattributed spend.