Shopify stores rarely have one tracking setup. They have a theme, marketing apps, pixels, and Google Tag Manager (GTM) trying to coordinate it all.
That's where the trouble starts.
When a Shopify app and GTM both try to "own" the same events especially checkout and purchase you end up with purchases double-counted, conversions missed, and inconsistent attribution between platforms. Even worse, you get bugs that only happen on certain devices or returning visitors.
This article explains what's happening, how to diagnose it, and how to design a tracking plan that stays stable as your stack grows.
The Hidden Cost of "Just Add One More Pixel"
Most tracking conflicts aren't caused by one "bad" tool. They're caused by overlap:
- An app injects a pixel automatically
- GTM also injects the same pixel
- A theme customization adds another script
- Checkout tracking behaves differently from storefront tracking
Individually, each change looks harmless. Together, they create a system where multiple components fire the same ecommerce events with slightly different timing and identifiers.
The result? Platforms disagree about what happened, and your team spends time arguing about which dashboard is "right."
What It Looks Like When Shopify Apps and GTM Conflict
Here are common symptoms that show up in real accounts:
1. Revenue is higher in ad platforms than in Shopify
Often caused by duplicate purchase events firing from multiple sources. This breaks your ecommerce conversion tracking and makes attribution tracking unreliable.
2. Purchases appear twice in analytics
You may see two purchase events within seconds, sometimes with the same order ID, sometimes with different IDs (or one missing the ID).
3. Add-to-cart looks fine, but purchase is unreliable
Storefront events can be easy to track, but checkout and post-purchase pages are where overlap and restrictions show up.
4. Returning customers "disappear"
If identifiers reset or cookies are blocked, repeat sessions look like new users. This hurts audience quality and lifecycle reporting.
5. Your GTM preview shows tags firing, but platforms don't receive them
Ad blockers and browser privacy features can prevent client-side requests from reaching endpoints even when GTM "fires."
Why Conflicts Happen: The 6 Most Common Causes
1. Two systems fire the same event
Example: A Shopify app fires Purchase automatically, while GTM fires a purchase tag from a data layer event.
Why it's tricky: Both are "correct" from their perspective. The platform receiving the event can't always deduplicate unless you provide consistent event IDs and order identifiers.
2. Mismatched event definitions
One setup fires purchase on thank-you page load, another fires on order confirmation, another fires on payment success.
Impact: Different timing changes counts when visitors refresh pages, hit the back button, or experience delayed redirects.
3. Missing or inconsistent deduplication keys
If one event includes an order ID or event ID and the other doesn't, platforms treat them as separate conversions.
Impact: Double counting or partial deduplication that only works sometimes.
4. Theme and app scripts bypass GTM
Even if you "manage everything in GTM," apps can still inject scripts directly into your theme or via app blocks.
Impact: You think GTM is the only source, but it's not.
5. Checkout environment differences
Shopify storefront pages and checkout pages don't behave the same way. With the August 28, 2025 deadline for Shopify checkout extensibility, additional scripts are being deprecated. Depending on your setup, some tags may not run where you expect.
Impact: Purchases get tracked by an app but not by GTM (or vice versa), creating gaps.
6. Browser restrictions and blockers
Client-side tags can be blocked or stripped, especially on mobile or privacy-focused browsers. This is where bot filtering becomes critical.
Impact: GTM reports a tag fired, but the network request never reaches the destination.
A Practical Debugging Checklist (What to Inspect and Where)
You don't need to guess. You need to trace one order end-to-end.
Step 1: Pick a single test order
Use a discount code and a unique product so you can find it everywhere.
Step 2: Check how many purchase events fired
In your browser dev tools:
- Open Network tab
- Filter for common tracking endpoints (you'll recognize them by domain/path)
- Place the test order
What you're looking for:
- Multiple requests that look like "purchase" firing more than once
- One request missing key fields (order ID, value, currency)
Step 3: Use GTM Preview Mode
Confirm:
- Which triggers fired
- Which tags fired
- Whether the purchase event fired more than once (e.g., on page load and on a custom event)
Step 4: Inspect your data layer payload
If you rely on GTM, verify the purchase payload includes:
- Order ID
- Value and currency
- Line items (if needed)
- A stable event identifier for deduplication (if your destinations support it)
Step 5: Inventory all tracking sources
Make a list of everything that can fire events:
- GTM container(s)
- Shopify apps that inject pixels
- Theme scripts (including "Additional scripts" areas)
- Any post-purchase or thank-you page scripts
If you find two sources tracking the same destination, that's your first place to simplify. This is where tracking pixel audits become essential—auditing tracking pixels helps you spot duplicates before they break your data.
A Clean Tracking Architecture for Shopify (Choose a Source of Truth)
The most reliable setups do one thing well: they define a single source of truth per event.
Here's a practical way to structure it:
Option A: GTM as the storefront orchestrator
Use GTM for:
- Content and engagement events (page view, product view)
- Non-critical marketing tags
Then ensure checkout and purchase is handled in one consistent way (not duplicated by apps).
Option B: App-managed tracking for critical commerce events
Use a dedicated Shopify app for:
- Add to cart, checkout, purchase
- Identity continuity and event consistency
Then keep GTM focused on what it's best at: managing client-side tags that don't overlap with your core conversion signals.
Option C: Server-side collection with controlled activation
This approach reduces reliance on browser execution for critical events. This is where Shopify server side tracking and server side tagging Shopify become game-changers.
- Collect important events through a server endpoint
- Forward them to destinations in a controlled, consistent way
Why teams choose this: Fewer gaps from blockers and fewer "mystery" duplicates caused by multiple browser scripts.
How to Simplify Shopify Server Side Tracking (without GTM)
Instead of wrestling with GTM configurations, checkout extensibility limitations, and duplicate event fires, Aimerce offers a cleaner path for attribution tracking and e-commerce conversion tracking.
What Aimerce does:
- Server side tracking Shopify setup: Collects events server-side, bypassing browser restrictions and ad blockers entirely
- Bot filtering: Automatically filters out bot traffic so your conversion data stays clean
- Klaviyo conversion tracking: Seamlessly integrates with Klaviyo for email attribution without manual setup
- Meta Conversion API Shopify: Sends purchase data directly to Meta using the offline conversions API, improving iOS tracking Shopify accuracy
- One source of truth: Eliminates the overlap between apps, GTM, and theme scripts
If you're tired of tracking and attribution conflicts, Aimerce gives you a single platform for accurate ecommerce events without the complexity of Shopify server-side tagging through GTM.
Looking for an Elevar alternative? Aimerce delivers the same server-side benefits with simpler setup and clearer pricing.
Comparison Table: GTM vs Aimerce Server-Side Tracking
| Approach | Pros | Cons | Best For |
|---|---|---|---|
| GTM-only | Flexible tag management; fast iteration for marketing teams | Exposed to browser restrictions and blockers; easy to duplicate tags when apps also inject scripts | Teams that need custom event tracking and have strong technical resources |
| Server-side (Aimerce) | Consistent event capture for critical signals; cleaner separation; bypasses ad blockers; includes bot filtering | Requires initial setup and monthly fees | Shopify Stores serious about accurate attribution tracking and scaling with clean data with no dev time |
How to Prevent Double Counting Across Ad Platforms and Analytics
Double counting usually isn't a "platform bug." It's an architecture issue.
Use these guardrails:
One purchase event definition
Decide exactly what counts as a purchase and when it fires.
One sender per destination
If a destination receives purchase from an app, don't also send purchase from GTM.
Consistent identifiers
Use stable order IDs and event IDs where supported.
Environment separation
Keep dev, staging, and test traffic separate from production reporting.
Change control
Treat tracking changes like code changes: document them, test them, and roll them out intentionally.
Best Practices for Klaviyo Server Side Tracking Setup
If you're running email campaigns through Klaviyo, server side tracking ensures every purchase gets attributed correctly even when browser-based pixels fail.
Steps for clean Klaviyo conversion tracking:
- Use Aimerce to send purchase events server-side to Klaviyo
- Include customer email, order ID, and product details in every event
- Set up flow triggers based on server-side purchase events (not pixel-based)
- Monitor attribution in Klaviyo's analytics to confirm consistency
This approach eliminates the "purchase showing up in Shopify but not Klaviyo" problem that happens when client-side pixels get blocked.
FAQ
Why does GTM say my purchase tag fired, but conversions don't show up?
Because "fired" means GTM executed the tag in the browser. The outbound request can still be blocked, fail, or be dropped before it reaches the destination. This is why server side tracking on Shopify is more reliable.
Why do I see two purchases for one order?
Most commonly: two different senders fired purchase (an app plus GTM, or two GTM tags). Less commonly, the purchase event fires on a page that can be reloaded, causing repeats.
Should I remove all Shopify app pixels and keep only GTM?
Not necessarily. The goal isn't "GTM everywhere." The goal is one owner per event per destination, plus consistent identifiers.
What's the fastest way to find the conflict?
Trace a single test order and count how many times the purchase is sent. Then list every script or app that could send it and eliminate overlap.
How does Aimerce compare to Elevar?
Aimerce offers similar server-side tracking capabilities as an Elevar alternative, but with simpler setup, transparent pricing, and built-in bot filtering. Both handle Shopify server-side tagging, but Aimerce focuses on eliminating GTM complexity entirely.
Future-Proof Your Tracking for Cleaner Data and Better Ad Performance
The cost of messy tracking isn't just bad dashboards. It's wasted ad spend, broken attribution, and decisions based on incomplete data.
The fix isn't adding more tools. It's choosing a clear ownership model for every event and sticking to it.
If you're running a growing DTC brand and need reliable tracking without the GTM headaches, consider Aimerce for server-side tracking on Shopify. You'll get accurate ecommerce conversion tracking, built-in bot filtering, seamless Klaviyo conversion tracking, and a single source of truth for all your attribution tracking needs.