The correct replacement for every purchase tag that lived in Additional Scripts is a custom pixel under Settings > Customer events, subscribing to the checkout_completed standard event via analytics.subscribe(). That is now the only supported path to checkout events on Basic, Shopify, and Advanced plans. The sandbox runs in an isolated iframe, so the approach is not a drop-in script swap, it is a small but deliberate rebuild.
Key takeaways
- Shopify ended Additional Scripts on the Thank You and Order Status pages for Shopify Plus stores on August 28, 2025 and for all non-Plus stores on August 26, 2026.
- The only supported route to
checkout_completedevents is now a web pixel (app pixel or custom pixel) registered under Settings > Customer events. - On January 13, 2026, Shopify changed the default data-sharing mode for app pixels from "Always on" to "Optimized", which can silently throttle or pause an app pixel.
- An app pixel activity log, released June 29, 2026, records every pause and resume from June 3, 2026 onward; custom pixels are exempt and have no activity log.
- Browser pixels still miss 15 to 25 percent of purchase events due to ad blockers and Safari ITP. Pairing a browser web pixel with server-side delivery (Meta CAPI, GA4 Measurement Protocol, TikTok Events API) and a shared event ID is the durable setup.
What actually changed, and when
Shopify's developer documentation states that checkout.liquid and additional scripts were sunset for the Thank You and Order Status pages on August 28, 2025. Non-Plus stores had until August 26, 2026 to upgrade the Thank You and Order Status pages. After August 26, the legacy Thank You Page and Order Status Page no longer exist for any Shopify store.
Any tracking pixel or script injected through the old Additional Scripts field stops firing the moment the auto-upgrade happens, with no warning and no rollback option after.
The upgrade also reached a surface people overlooked: returning buyers checking order status. Web pixels auto-load on the Order status page and custom-domain customer accounts since July 21, 2025, replacing the old "returning buyer" scripts.
How the Web Pixels sandbox works
Understanding the execution environment saves debugging time later.
The sandbox is an isolated context for custom and app pixels with no access to the store's window or DOM. Data comes only via analytics.subscribe(), and storage uses a restricted browser API.
Instead of your store pushing objects into a global array and tags pulling from it, Shopify emits a typed event stream and tracking code subscribes to it. The Customer Events API is the catalog of events Shopify emits (page_viewed, product_viewed, checkout_completed, and around 20 others) plus the payload schema for each one. The Web Pixel API is the runtime sandbox where your subscriber code runs, with the analytics.subscribe method and the scoped browser global.
Practical consequence: you cannot call window.fbq(), window.gtag(), or window.ttq.track() from inside the sandbox unless you explicitly load the vendor SDK inside the pixel code first. The sandbox has no access to the parent page's globals.
The checkout_completed payload you actually get
Subscribe to Shopify's standard customer events and you get well-formed data handed to you. checkout_completed is the purchase signal, and you get the order total, currency, and line items from the event payload directly, no scraping required.
Here is the minimal structure every platform needs:
analytics.subscribe('checkout_completed', (event) => {
const checkout = event.data.checkout;
const orderId = checkout.order?.id; // Shopify order GID
const value = checkout.totalPrice?.amount;
const currency = checkout.currencyCode;
const lineItems = checkout.lineItems; // array with variant, quantity, price
// Use orderId as your deduplication key when pairing with server-side.
});
The orderId here is a Shopify GID string (e.g. gid://shopify/Order/5678). Strip the numeric suffix for platforms that expect a plain integer, or pass the whole string and configure the server-side integration to match.
Shopify triggers checkout_completed once per checkout, normally on the thank-you page. When a post-purchase upsell runs, it fires on the first offer page instead and is not triggered again on the thank-you page. If you run post-purchase offers, verify this in your test flow.
GA4, Meta, and TikTok: approach comparison
| Platform | App pixel (native channel) | Custom pixel | Server-side complement | Deduplication key |
|---|---|---|---|---|
| GA4 | Google & YouTube app (browser + server since July 2026) | Custom pixel with gtag.js loaded inside sandbox | GA4 Measurement Protocol | transaction_id = Shopify order ID |
| Meta | Meta Sales Channel app pixel | Custom pixel loading fbq inside sandbox | Meta Conversions API (CAPI) | event_id shared across browser and CAPI |
| TikTok | TikTok Sales Channel (browser only as of 2026) | Custom pixel loading ttq inside sandbox | TikTok Events API (manual or via middleware) | event_id within 48 hours |
GA4
In July 2026, Shopify started sending purchases to GA4 server-side. Any store with the Google & YouTube app installed now has its purchase event pushed from Shopify's servers to GA4 through Google's Data Manager API, bypassing the browser entirely. That is a meaningful improvement, but it covers GA4 only. If you rely on the native app for GA4 and nothing else, test that the server-side path is active before trusting the numbers.
For a custom pixel approach that gives you full control over event parameters:
analytics.subscribe('checkout_completed', (event) => {
const checkout = event.data.checkout;
// Load gtag inside the sandbox, then fire:
gtag('event', 'purchase', {
transaction_id: checkout.order?.id,
value: parseFloat(checkout.totalPrice?.amount),
currency: checkout.currencyCode,
items: checkout.lineItems.map(li => ({
item_id: li.variant?.product?.id,
item_name: li.title,
quantity: li.quantity,
price: parseFloat(li.variant?.price?.amount)
}))
});
});
Verify with GA4 DebugView. In your GA4 property, go to Configure > DebugView. Trigger events on your storefront and watch them appear in real time.
Meta
The Meta Sales Channel app pixel installs via Customer events and handles the browser-side Purchase event. The critical pairing is Meta's Conversions API for server-side delivery. A tracking app listening there can deliver the purchase to GA4, Meta, TikTok, Google Ads, and the rest with the full order record attached, and if the browser event also fired, event deduplication by shared event ID keeps the two paths from double counting.
Verify in Meta Events Manager. Meta Events Manager's Diagnostics tab shows Pixel and CAPI status with deduplication percentage. You want to see both browser and server events arriving with matched event_id values, and the deduplication percentage should be near 100 percent for purchase events.
TikTok
As of 2026, Shopify's native TikTok Sales Channel integration installs only a browser-side pixel through the Customer Events system. Shopify's native TikTok channel does not send server-side Events API calls. That means TikTok purchases are still fully dependent on the browser pixel firing, which makes the browser-side signal especially important to protect.
iOS 14+ and ad blockers suppress browser pixel purchase events on affected traffic segments, making Events API coverage meaningful for stores with consistent TikTok ad spend. The fix is to add a TikTok Events API layer, fed from the orders/create webhook or a middleware service, with a shared event_id.
The January 2026 "Optimized" mode problem
This is the silent issue that broke tracking for stores that thought they had migrated correctly.
On January 13, 2026, Shopify introduced a new default setting for marketing pixels. App pixels now default to "Optimized" mode instead of "Always on." This change affects how Shopify handles data flow from third-party app pixels, but it does not affect all tracking setups equally.
"Optimized" mode monitors pixel performance and may restrict data flow if Shopify detects no attribution signals over days or weeks. Shopify does not notify you when it restricts a pixel's data flow. There is no email, no banner in your admin, no alert in your Customer Events settings.
Custom pixels pasted into Customer events run as written, with no data-sharing Mode and no activity log, so neither Optimized pauses nor log entries apply to them. This is the strongest argument for using a custom pixel over a third-party app pixel for your primary conversion events.
Shopify's app pixel activity log, released June 29, 2026, records every change to what customer data each app pixel can access, with history starting June 3, 2026. Check it at Settings > Customer events by clicking into any app pixel's detail page.
If you are keeping an app pixel (Meta, TikTok, or similar): you can manually switch any app pixel to "Always on" mode to guarantee 100% data flow.
What to verify after migrating
Do not trust that a pixel showing "Connected" means it is firing correctly. Connected and firing are two different things, and Shopify's built-in Pixel Helper is how you tell them apart in real time.
Browser-side verification checklist:
- Place a real test order (do not use the preview order simulator for final sign-off).
- Open the Pixel Helper extension during checkout and confirm
checkout_completedfires with the expected payload. - Check GA4 DebugView for a
purchaseevent with correcttransaction_id, value, and currency. - Check Meta Events Manager > Test Events for a
Purchaseevent with the correctevent_id. - Check TikTok Events Manager for a
CompletePaymentevent with matching pixel signal.
Server-side deduplication check:
- Compare the order ID, value, and currency in Shopify, GA4, Meta, Google Ads, and TikTok.
- Meta Events Manager Diagnostics tab shows Pixel and CAPI status with deduplication percentage. GA4 DebugView and Realtime report show live events as they fire. Make a test purchase and confirm all three show exactly one purchase event with correct parameters.
App pixel mode check:
- Navigate to Settings > Customer events > App pixels tab. Look at the Data column.
- If a pixel matters this quarter, set it to Always On. Click the pixel's setting in the Data column, change Mode to Always On, save.
The case for server-side as the primary path
Move purchase-confirmation logic off the Thank You page where possible. Server-side tracking via the orders/create webhook is more reliable long-term than any client-side script on a page that may not even load for every customer, since checkout_completed can sometimes fire before that page renders at all.
For purchase events, sending them server-side (Meta's Conversions API, Google's enhanced conversions) recovers the data browser pixels lose to ad blockers and Safari ITP, typically 15 to 25 percent more captured events.
The practical architecture for a store running all three platforms is:
- Browser web pixel (custom pixel) subscribed to
checkout_completed, fires immediately on the thank-you page with the full order payload and a generatedevent_id. orders/createwebhook fires server-side with the sameevent_idstored against the order (via order attributes or a note attribute written during checkout). Sends to Meta CAPI, GA4 Measurement Protocol, and TikTok Events API.- Deduplication is handled by matching
event_id(Meta, TikTok) ortransaction_id(GA4, Google Ads) across the two paths.
Shopify Functions and checkout UI extensions cannot access tracking payloads, so the browser pixel and webhook remain the two correct surfaces for purchase signals.
If you maintain a large catalog (I work across stores with 10,000+ SKUs where order volume makes event loss immediately visible in ROAS), the server-side webhook path is the one that holds up. Browser pixels degrade silently over time as ad blocker adoption grows; webhooks do not.
Frequently asked questions
Do I need Shopify Plus to use Web Pixels for purchase tracking?
No. The Web Pixels API, app pixels, and the custom pixel editor under Settings > Customer events are available on all Shopify plans, including Basic. Shopify Plus stores simply hit the August 28, 2025 deadline earlier than non-Plus stores.
Why is checkout_completed firing but GA4 or Meta is not recording the purchase?
The two most common causes are a consent permission mismatch (the pixel requires Marketing consent but the visitor declined) and the app pixel being throttled by Shopify's Optimized data-sharing mode introduced on January 13, 2026. Check the Data column in Settings > Customer events and switch critical pixels to Always On. Also verify inside GA4 DebugView and Meta's Test Events tool with a real test order.
How do I deduplicate browser and server-side purchase events so they do not double-count?
Generate a unique event_id string (for example, a UUID) in the browser pixel when checkout_completed fires, write it to the Shopify order as a note attribute or order attribute, then read it from the orders/create webhook payload when sending the server-side hit. Meta matches on event_id, GA4 and Google Ads match on transaction_id, which should be your Shopify order ID.