GA4 Purchase Event Not Firing on Shopify: Fix Guide

The GA4 purchase event is the critical ecommerce event that records a completed transaction. When a customer finishes checkout on your Shopify store, a purchase event should fire and send transaction data — including order ID, revenue, tax, shipping, and item details — to your GA4 property.

On Shopify, there are three main ways this event gets triggered: through the Google & YouTube channel app (which injects GA4 tracking automatically), through Google Tag Manager with a custom purchase event tag, or through a Shopify Web Pixel that sends events via the Customer Events API. Each method has different failure points, which is why diagnosing the problem requires understanding which method your store uses.

If the purchase event is not firing, GA4 shows zero or incomplete ecommerce revenue data, your Google Ads campaigns cannot optimize for purchase conversions, and any audience segments built on purchasers will be empty. The downstream effects compound quickly — Smart Bidding loses the signal it needs to find high-value customers.

Before troubleshooting causes, confirm whether the purchase event is actually missing. There are three reliable methods to check:

The simplest explanation: your GA4 measurement tag is either not present on the checkout/order confirmation page, or it's configured with the wrong Measurement ID. This accounts for roughly 35% of cases we see.

If you're using the Google & YouTube channel app, the GA4 tag is injected automatically. But the app requires your GA4 property to be correctly linked — if the connection was broken (common after Google account changes or GA4 property migrations), the tag stops loading silently. There's no error message in Shopify; it just stops working.

If you set up GA4 manually using a gtag.js snippet or Google Tag Manager, the Measurement ID (G-XXXXXXXXXX) must exactly match your GA4 property. A common mistake is using the old Universal Analytics ID (UA-XXXXXXX) instead of the GA4 Measurement ID, or copying the ID from a different GA4 property.

How to Diagnose:

• Open your store's order confirmation page in Chrome and press F12 to open Developer Tools
• Go to the Network tab and filter by 'collect' — look for requests to google-analytics.com/g/collect
• If no requests appear, the GA4 tag is not loading on the page
• If requests appear, check the 'tid' parameter in the request URL — it should match your GA4 Measurement ID

How to Fix:

• If using the Google & YouTube channel app: disconnect and reconnect the GA4 property in the app settings. Verify the correct GA4 property is selected.
• If using gtag.js: confirm the snippet is present in theme.liquid and that the Measurement ID matches your GA4 property. Check Admin > Data Streams in GA4 for the correct ID.
• If using GTM: verify the GA4 Configuration tag has the correct Measurement ID and that the GTM container snippet loads on all pages including checkout.
• For all methods: clear your browser cache and test in an incognito window to rule out caching issues.

If you're using Google Tag Manager to fire the GA4 purchase event, the trigger configuration is critical. The event fires correctly only when the trigger conditions match the actual checkout completion flow on your Shopify store. A mismatch means the tag exists but never gets the signal to fire.

The most frequent trigger misconfiguration is using a Page View trigger with a URL matching rule like 'Page URL contains thank_you' — this used to work reliably, but Shopify has changed the order confirmation URL structure multiple times. Some stores now use '/checkouts/cn/' URLs, others use '/orders/' URLs, and the exact pattern depends on your Shopify plan, checkout configuration, and whether you've migrated to Checkout Extensibility.

Another common mistake: setting up a custom event trigger for 'purchase' but not having a Data Layer push that sends the purchase event. The GA4 tag sits in GTM waiting for an event that never arrives because nothing on the page pushes it to the Data Layer.

How to Diagnose:

• Open GTM in Preview mode and complete a test purchase
• Check the Tag Fired/Not Fired summary on the order confirmation page
• If your GA4 purchase event tag appears under 'Tags Not Fired,' click it to see which trigger conditions failed
• Verify the Data Layer contains a 'purchase' event with the required ecommerce parameters

How to Fix:

• Replace URL-based Page View triggers with a Custom Event trigger that fires on the 'purchase' Data Layer event
• If using Shopify's native Data Layer, verify the event name matches exactly (case-sensitive) — 'purchase' not 'Purchase' or 'purchase_complete'
• Add a Data Layer push script to the order confirmation page if one doesn't exist. The script should push event: 'purchase' along with ecommerce data (transaction_id, value, currency, items).
• Test in GTM Preview mode after every change to confirm the tag fires correctly

This is the most disruptive recent change affecting GA4 tracking on Shopify. As part of the Checkout Extensibility migration, Shopify removed support for checkout.liquid customizations. Any JavaScript tracking scripts that were injected via checkout.liquid — including GA4 purchase event scripts and GTM containers on checkout pages — stopped executing.

The migration happened at different times for different stores, but by August 2025, all Shopify Plus stores were migrated. If your GA4 purchase tracking was working before the migration and suddenly stopped, this is the most likely cause. The tracking scripts physically exist in your checkout.liquid file, but Shopify no longer renders that file during checkout.

This doesn't affect tracking on non-checkout pages. Your GA4 tag still fires on product pages, collection pages, cart pages, etc. It specifically impacts the checkout and order confirmation pages where the purchase event should fire.

How to Fix:

• Migrate your GA4 purchase tracking to a Shopify Web Pixel (custom pixel). Web Pixels use the Customer Events API and run in a sandboxed environment on checkout and order confirmation pages.
• In your Shopify admin, go to Settings > Customer events > Add custom pixel. Create a pixel that subscribes to the 'checkout_completed' event and sends a GA4 purchase event via the Measurement Protocol or gtag.js.
• If using GTM, note that GTM containers cannot run inside Web Pixels due to Shopify's sandbox restrictions. You need to either send events directly via gtag.js inside the pixel or use server-side GTM with the Measurement Protocol.
• Alternatively, install a tracking app like ScaleUp that handles this migration automatically and fires purchase events via Shopify's official APIs.

If you've set up a Shopify Web Pixel for GA4 tracking but the purchase event still isn't firing, the pixel configuration itself may be the issue. Web Pixels run in a sandboxed iframe, which means they have different capabilities and limitations compared to regular JavaScript on the page.

Common Web Pixel problems include: subscribing to the wrong event name (Shopify uses 'checkout_completed' not 'purchase'), not properly formatting the GA4 event payload, using browser APIs that are blocked inside the sandbox (like accessing document.cookie or localStorage), or the pixel being set to 'Disabled' in Shopify admin.

Another subtle issue: Web Pixels are customer-event pixels, and Shopify distinguishes between 'App pixels' (installed by apps, always active) and 'Custom pixels' (created manually, require explicit activation). If you created a custom pixel but forgot to connect and enable it, it won't execute.

How to Diagnose:

• Go to Settings > Customer events in your Shopify admin
• Check that your GA4 pixel is listed and shows 'Connected' status
• Review the pixel code for the correct event subscription: analytics.subscribe('checkout_completed', ...)
• Check the browser console on the order confirmation page for errors from the pixel sandbox

How to Fix:

• Ensure the pixel subscribes to 'checkout_completed' (not 'purchase') — this is Shopify's event name for completed orders
• If using gtag.js inside the pixel, initialize it properly with your Measurement ID before sending the purchase event
• Avoid using blocked APIs inside the sandbox. Use the event data provided by Shopify (event.data.checkout) instead of trying to read cookies or DOM elements.
• Toggle the pixel off and on again in Shopify admin, then test with a new checkout. Sometimes pixels need to be reconnected after code changes.
• Check that the pixel isn't throwing JavaScript errors by reviewing the browser console — pixel errors are logged with a '[Custom Pixel]' prefix

If your store uses a cookie consent banner — required for selling to EU, UK, and other regulated markets — the GA4 purchase event may not fire for customers who decline tracking consent. With Google Consent Mode v2, if ad_storage and analytics_storage are denied, GA4 events are either blocked entirely or sent without cookies (depending on your implementation).

The tricky part is that Consent Mode can silently suppress events without any visible error. Your tracking works perfectly for consenting customers, but for non-consenting ones, the purchase event never reaches GA4. If a large percentage of your traffic is from privacy-conscious markets, this can account for 30-60% of missing purchase events.

There's also a configuration error that's surprisingly common: the consent default is set to 'denied' for all regions, but the consent banner never triggers the update command to grant consent when a customer clicks 'Accept.' This means every visitor is treated as having denied consent, even those who explicitly accepted.

How to Fix:

• Verify your Consent Mode implementation sends a consent 'update' command when customers accept cookies. Check with Tag Assistant — the consent state should change from 'denied' to 'granted' after acceptance.
• Ensure consent defaults are configured correctly: 'denied' for EU/EEA regions, 'granted' for regions without consent requirements. Don't apply blanket 'denied' to all regions.
• Enable GA4's Consent Mode behavioral modeling (Admin > Data Settings > Data Collection) to fill gaps from non-consenting users with modeled data.
• If using a consent management platform (CMP) like Cookiebot, OneTrust, or Pandectes, verify it's properly integrated with Google Consent Mode v2 and sending the correct consent signals.

A JavaScript error on the order confirmation page can silently prevent the GA4 purchase event from firing. If any script that executes before your GA4 tracking code throws an unhandled error, it can block all subsequent scripts from running. Your GA4 tag never gets a chance to execute.

This is particularly common on Shopify stores with many installed apps. Each app may inject its own JavaScript on the order confirmation page, and a bug in any one of them can cascade into a tracking failure. Theme updates can also introduce JavaScript conflicts, especially if custom code was added to the theme that's incompatible with the updated version.

The symptoms are intermittent tracking: the purchase event fires sometimes but not always. This happens when the error is caused by a race condition — scripts loading in a different order on different page loads. One time the GA4 tag loads and fires before the problematic script; another time it doesn't.

How to Diagnose:

• Open Chrome Developer Tools (F12) on the order confirmation page
• Check the Console tab for red error messages, particularly any errors that appear before your GA4 tag loads
• Look for errors referencing 'undefined' variables, failed network requests for external scripts, or CORS errors
• Try disabling other Shopify apps temporarily to see if the purchase event starts firing

How to Fix:

• Identify and fix the JavaScript error. If it's from a third-party app, contact the app developer or temporarily disable the app to restore tracking.
• Wrap your GA4 tracking code in a try-catch block to prevent other scripts' errors from blocking it. Place your GA4 script as early as possible in the page load order.
• Move to event-based tracking via a Web Pixel instead of injected scripts. Web Pixels run in an isolated sandbox, so they're not affected by JavaScript errors on the main page.
• If using GTM, check that the GTM container loads independently of other scripts by placing it in the section. GTM has its own error handling that should prevent most cascade failures.

Each of the six causes above requires a different fix, and even after you solve one, another can break your tracking next month. Shopify updates its checkout flow, browsers change privacy behavior, apps introduce conflicts — the environment is constantly shifting.

ScaleUp eliminates these issues by firing GA4 purchase events through Shopify's official Web Pixel API and server-side Measurement Protocol. Instead of relying on client-side JavaScript that can be blocked, broken, or suppressed by consent, ScaleUp sends purchase data directly from Shopify's servers to GA4 with full ecommerce parameters.

This approach is resilient to all six causes covered in this guide: it doesn't depend on theme code or checkout.liquid, it uses Shopify's native checkout_completed event (not URL-based triggers), it works regardless of JavaScript errors on the page, and it includes Enhanced Conversions data for better attribution even when cookies are blocked.