Why does my tracking work on the site but not on checkout?

Checkout is served by Shopify and doesn't run your theme scripts. Any pixel there runs in the sandboxed Customer Events environment, which can't read the page DOM or your data layer. Scripts that scrape the DOM or expect global window variables silently do nothing on checkout.

Can I use Google Tag Manager in Shopify Customer Events?

You can load GTM inside a custom pixel, but it runs in the sandbox — so GTM tags that read the DOM, use the standard data layer, or manipulate the page won't behave normally. The reliable pattern is to subscribe to Shopify's standard events and pass that data to your tags, or to run tracking server-side.

Shopify Customer Events & the Web Pixel Sandbox — Why Your Tags 'Disappear'

Q: What is the Shopify web pixel sandbox?

Custom and app pixels added through Shopify Customer Events run in an isolated sandbox — a separate context with no access to the store's window or DOM. They receive data only through Shopify's analytics.subscribe() event API and interact with cookies/storage through a restricted browser API. It exists to protect performance, security and customer privacy.

Q: How do I read cookies inside a Shopify custom pixel?

Not with document.cookie — the sandbox blocks it. Shopify exposes a restricted browser API (browser.cookie, browser.localStorage, browser.sessionStorage) that returns promises. You must use that API instead of touching the document directly.

Here’s a bug that makes people lose an afternoon: your Meta Pixel or GA4 tag works perfectly on product and cart pages, then goes completely silent on checkout and the thank-you page — no errors, no purchase event, nothing. Everything looks installed.

The culprit is almost always the same: Shopify’s Customer Events / Web Pixels sandbox. Once you understand what it does, the “disappearing” tags make sense — and the fix is straightforward.

What the sandbox is

Any pixel you add through Settings → Customer events (as a custom pixel, or one installed by an app) runs in a sandboxed environment — an isolated JavaScript context that is deliberately walled off from your storefront. It is not running in the normal page like a theme script.

Shopify built this for performance, security and privacy: a third-party pixel can’t slow your store, tamper with the page, or read data it shouldn’t. But that isolation is exactly why old-style tracking breaks.

What the sandbox blocks (and why tags “disappear”)

Inside the sandbox, your code cannot:

Access the store’s window or global variables.
Read or manipulate the page DOM (document.querySelector, scraping prices off the page, etc.).
Touch cookies via document.cookie.

So the two most common legacy patterns fail silently:

DOM-scraping tags — anything that reads order values, emails or product data out of the rendered page. The DOM isn’t there, so the tag runs but collects nothing.
Global-variable / data-layer assumptions — tags expecting window.dataLayer or a theme-injected object. Those globals don’t exist in the sandbox.

No exception is thrown, so it feels like the tag “disappeared.” It’s actually running — just blind.

How you’re meant to track inside it

The sandbox replaces DOM-scraping with a clean, structured event API. You subscribe to Shopify’s standard customer events and get well-formed data handed to you:

analytics.subscribe("checkout_completed", (event) => {
  const checkout = event.data.checkout;
  // send checkout.order, totalPrice, lineItems to your destination
});

Key standard events include page_viewed, product_viewed, product_added_to_cart, checkout_started, and — the one that matters most — checkout_completed (your purchase signal). You get the order total, currency and line items from the event payload directly, no scraping required.

For storage, use Shopify’s restricted browser API (browser.cookie, browser.localStorage, browser.sessionStorage) — which return promises — instead of document.cookie.

The practical playbook

Install GA4 and Meta the supported way. Prefer Shopify’s official Google & YouTube and Meta channel apps, or a custom pixel that subscribes to standard events — not a theme-injected script that dies on checkout. (This is doubly true after the checkout.liquid migration, which removed the old script injection point entirely.)
Stop scraping the DOM. Read values from the event payload (event.data...), which is more reliable anyway.
Move heavy matching server-side. Because the sandbox limits what the browser can do and cookies are increasingly capped, the durable pattern is server-side tracking: the checkout_completed event (or Shopify webhooks) feeds a server container that forwards to GA4 and Meta CAPI with full match data.
If the purchase event is missing entirely, work the purchase event not firing checklist — sandbox subscription errors are a frequent cause.

Quick diagnosis

Symptom	Sandbox cause	Fix
Works on site, silent on checkout	Theme script doesn’t run in checkout/sandbox	Use a custom pixel or channel app that subscribes to events
Tag runs but sends empty values	DOM scraping — no DOM in sandbox	Read from the `event.data` payload
`document.cookie` returns nothing	Blocked in sandbox	Use `browser.cookie` (promise-based)
GTM tags behave oddly	GTM running sandboxed	Subscribe to standard events / go server-side

Not sure if your checkout is even firing a clean purchase event? The free Tracking-Health Mini-Audit checks your purchase event, duplicates and server-side path in ~10 minutes.

FAQ

What is the Shopify web pixel sandbox? An isolated context for custom/app pixels with no access to the store’s window or DOM — data comes only via analytics.subscribe(), storage via a restricted browser API.

Why does tracking work on-site but not on checkout? Checkout runs Shopify’s code, not your theme scripts; pixels there run sandboxed and can’t read the DOM or data layer.

Can I use GTM in Customer Events? You can load it, but it runs sandboxed — DOM/data-layer tags misbehave. Subscribe to standard events or track server-side instead.

How do I read cookies in a custom pixel? Use browser.cookie (promise-based), not document.cookie, which the sandbox blocks.

Sources

Shopify — Customer events (help center)
Shopify — Web Pixels API & the pixel sandbox (dev docs)
Shopify — Standard events reference (analytics.subscribe)