Quick Answer
The GA4 purchase event on Shopify most commonly fails because of a missing or misconfigured GA4 tag, a wrong GTM trigger, scripts removed during Checkout Extensibility migration, or Consent Mode blocking the event. Use GA4 DebugView (Admin > DebugView) or Google Tag Assistant to confirm whether the event fires on the order confirmation page. Then work through the six causes below to identify and fix the specific issue.
How the GA4 Purchase Event Should Work on Shopify
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.
How to Verify the Purchase Event Is Firing
Before troubleshooting causes, confirm whether the purchase event is actually missing. There are three reliable methods to check:
Note
Always test with a real checkout flow, not by navigating directly to a thank-you page URL. Shopify's order confirmation page requires an active checkout session — visiting the URL directly without completing checkout will show a different page and won't trigger purchase events.
GA4 DebugView
Go to Admin > DebugView in your GA4 property. Enable debug mode by installing the Google Analytics Debugger Chrome extension, then place a test order. Watch the event stream in real time — you should see a 'purchase' event appear with ecommerce parameters (transaction_id, value, items). If you see page_view events but no purchase event, the event is not firing on the order confirmation page.
GA4 Realtime Reports
Navigate to Reports > Realtime in GA4. After placing a test order, check the Event count by Event name card. If 'purchase' does not appear within a few minutes, the event is not being sent. Note that Realtime reports have a slight delay and may not show parameter details — DebugView is more precise for debugging.
Google Tag Assistant
Open Tag Assistant (tagassistant.google.com), connect it to your store, and navigate through a test purchase. Tag Assistant records every tag that fires on each page and shows the data sent. On the order confirmation page, look for your GA4 configuration tag and the purchase event. If the tag appears but the purchase event is missing, the trigger is the problem. If the tag doesn't appear at all, the installation is the problem.
Cause #1: GA4 Tag Not Installed or Misconfigured
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.
Cause #2: Wrong Trigger or Event Configuration in GTM
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
Stop losing GA4 purchase data
ScaleUp sends GA4 purchase events server-side with full ecommerce parameters, Enhanced Conversions, and automatic deduplication.
Install Free on ShopifyRated 5.0 on Shopify App Store
Cause #3: Checkout.liquid Scripts Removed (Checkout Extensibility Migration)
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.
Warning
If your store was migrated to Checkout Extensibility and your GA4 tracking used checkout.liquid scripts, those scripts are permanently disabled. Shopify will not restore checkout.liquid support. You must migrate to a Web Pixel or a tracking app.
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.
Cause #4: Web Pixel Not Installed or Not Configured Properly
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
Cause #5: Consent Mode Blocking the Event
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.
Cause #6: JavaScript Errors Preventing the Event from Firing
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.
The Automated Fix: How ScaleUp Handles GA4 Purchase Events
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.
Fix GA4 Purchase Tracking Permanently
ScaleUp automatically fires GA4 purchase events with correct ecommerce data, transaction ID deduplication, and Enhanced Conversions. No GTM configuration, no checkout.liquid scripts, no ongoing maintenance. Install in 60 seconds.
Install Free on ShopifyHow to Verify Your Fix Worked
After applying a fix, confirm that GA4 is now receiving purchase events:
- 1Enable GA4 DebugView (install the Google Analytics Debugger extension in Chrome).
- 2Place a test order using a 100% discount code or small-value product. Complete the full checkout flow.
- 3In GA4 DebugView, confirm a 'purchase' event appears with the correct transaction_id, value, and currency parameters.
- 4Check GA4 Realtime reports (Reports > Realtime) to verify the event appears in the Event count by Event name card.
- 5Wait 24-48 hours, then check the Monetization > Ecommerce purchases report in GA4. Your test transaction should appear with the correct revenue.
- 6Monitor for the next 7 days, comparing Shopify orders against GA4 purchase events. The match rate should be 85-95% (some gap is normal due to consent and ad blockers).
Sources

Written by Jamie Scott
Founder & CEO, ScaleUp
Jamie specializes in e-commerce conversion tracking, helping Shopify merchants improve their Google Ads performance through better data accuracy.
Google Ads & Shopify conversion tracking experts
Have questions about this article? Check our FAQ or contact us.
Related Resources
Ready to fix your tracking?
Get accurate Google Ads conversion tracking on Shopify in under 5 minutes.