Shopify Checkout Extensibility After the Non-Plus Deadline

August 26, 2026 was the last date for Shopify stores on non-Plus plans to upgrade their Thank you and Order status pages to checkout extensibility, and any conversion tracking still sitting in the Additional Scripts box or in app script tags is the part most likely to have gone quiet. This guide covers what changed, how to check in a few minutes whether your tracking survived, and the code to rebuild it now. We rebuild checkout tracking as part of our Shopify e-commerce practice.

Three facts carry most of the weight. Shopify's upgrade guide now says "August 26, 2026 was the deadline for stores on a non-Plus Shopify subscription plan to upgrade." Shopify's developer docs say script tags stopped running on the Order status page for non-Plus stores on that date. And the Additional Scripts box has been view-only since August 28, 2025, so nothing in it can be edited. Every date and limitation below links to Shopify's own documentation, read again on October 12, 2026.

The 60-second version

• What passed: the August 26, 2026 upgrade deadline for non-Plus Thank you and Order status pages (Shopify Help Center).
• Scope: the Thank you and Order status pages only, not the whole checkout.
• What stopped: app script tags on the Order status page (August 26, 2026 for non-Plus). Additional Scripts are not supported on the new pages, so any tracking left there does not carry over.
• How to check: Settings > Checkout. If an upgrade notice still shows in the Configurations section, you are on the deprecated pages.
• What's unknown: Shopify's docs don't say what happened to non-Plus stores that missed the deadline; check Settings > Checkout rather than assuming.
• The fix: rebuild tracking as Web Pixels and page content as app blocks or checkout UI extensions, then verify with a real test order.

What checkout extensibility is (and what it replaced)

Checkout extensibility is Shopify's set of sandboxed, upgrade-safe APIs that replaced raw JavaScript and Liquid in script boxes. For years, customizing the post-purchase pages meant pasting code into those boxes; the new tools run where Shopify controls them, so a checkout update can't be broken by a third-party script. Each one maps to a legacy mechanism:

The Web Pixels API gives pixels "a set of controlled APIs for accessing browser APIs and subscribing to customer events, within one of our Lax or Strict sandboxes" (shopify.dev: Web Pixels API).

The timeline: what already happened

Every date in the checkout extensibility rollout has now passed, including the Scripts shutdown for Plus stores. Here they are in order, with who each one applied to:

One thing Shopify's current pages don't say: what it did to non-Plus stores that hadn't upgraded by August 26. The upgrade guide states that stores on the Pause and Build plan, and stores that pause, are upgraded automatically, and that "if a notice to upgrade your Thank you and Order status pages displays, then it means you're still using the deprecated versions." So don't assume either way. Check your own store; it takes a few minutes.

Check whether your tracking survived

Three checks tell you where you stand, in this order:

1. Page version. Go to Settings > Checkout and look at the Configurations section. An upgrade notice means you are still on the deprecated pages and need to finish the upgrade. No notice means the new pages are live.
2. A real test order. Place one order and confirm that Google Ads, Meta and GA4 each record the purchase with the right value and currency. This is the only check that proves events are firing, whatever the admin says. It's also the first measurement check in our Shopify conversion rate optimization playbook.
3. The conversion trend. Compare purchase conversions in each ad platform for the weeks before and after August 26. A sudden step down on that date points at a tag that lived in a script box or a script tag.

If you manage several stores, the Admin GraphQL CheckoutProfile object has a typOspPagesActive field, described as "Whether the checkout profile Thank You Page and Order Status Page are actively using extensibility or not" (shopify.dev). Shopify's script tag docs point developers to it. Note that the checkoutProfile and checkoutProfiles queries are marked deprecated in the latest API reference, so confirm the version you call still returns them.

The scope trap: for non-Plus, your checkout did not break

checkout.liquid "is available only to Shopify Plus merchants" (shopify.dev). If you're on a standard plan, you never had it, and the Information, Shipping and Payment steps of your checkout were always Shopify-hosted and untouched by this change.

For a standard store, the entire blast radius is the Thank you page, the Order status page, and the script boxes attached to them. Knowing this is the difference between scoping a tidy week of work and quoting a checkout rebuild that was never necessary.

What stopped working

Two legacy mechanisms no longer reach the post-purchase pages, and they took revenue infrastructure with them:

1. The Additional Scripts box (Settings > Checkout). It has been view-only since August 28, 2025, and Shopify says additional scripts "aren't supported on the new Thank you and Order status pages" (Shopify Help Center).
2. App script tags on the Order status page. Apps couldn't create them from February 1, 2025, and they stopped running for non-Plus stores on August 26, 2026 (shopify.dev).

In practice, the casualties are almost always tracking and post-purchase tooling:

• Google Ads conversion tags and Meta Pixel purchase events
• GA4 and Google Tag Manager containers
• TikTok, Pinterest and other channel pixels
• Affiliate and partner network scripts
• Post-purchase upsell HTML and NPS or survey snippets

Nothing visibly errors on the storefront when a tag stops, so the usual first sign is a weekly ad report with conversions down and orders flat.

Why tracking breaks silently: the Web Pixels sandbox

Web Pixels don't run on the page the way Additional Scripts did; they run in a sandbox and respond to events instead of reading the checkout page. There are two sandbox modes (shopify.dev: pixels overview):

The mental shift: you no longer inject a script that reads the page. You subscribe to events Shopify emits (checkout_completed, payment_info_submitted, product_added_to_cart and so on) and react to their structured payloads. There is no store-page window.dataLayer to read and no checkout DOM to scrape. Code written for the old model doesn't "mostly work" here; it does nothing.

Consent: why your numbers will legitimately drop

Shopify says that after you replace additional scripts with pixels, "you might notice a decrease in events received by the third-party platform," because "app pixels and custom pixels only track customer behavior with consent, whereas consent is often not set up properly in additional scripts" (Shopify Help Center). In markets configured to require consent, such as the EEA and the UK, pixels run only when the visitor has given the permissions set in the pixel's configuration, and new custom pixels require Marketing and Analytics permissions by default (Shopify Help Center).

So after a correct migration, expect a gap between GA4 purchase events and Shopify orders. The skill is telling consent from breakage, which is why the monthly test later in this guide compares ratios over time instead of reading a single day.

The audit: inventory every tag before you rebuild

Shopify generates a personalized upgrade guide for every store that lists the existing customizations on these pages. Open it from Settings > Checkout, then click Review on the upgrade notice in the Configurations section. If you already upgraded, the old snippets are still worth recovering from your own notes, tag manager history or agency handover docs. Then:

1. Copy every snippet from the Additional Scripts box somewhere safe. The box is view-only, so you can read it but not edit it.
2. Classify each snippet by destination:
   • Tracking (gtag, fbq, GTM, TikTok) becomes a Web Pixel
   • UI or content (banners, custom thank-you messaging) becomes a checkout UI extension or app block
   • Cart or discount logic becomes a Shopify Function or app (see the Plus note below)
3. Check installed apps for compatible versions. The upgrade guide lists apps that have been updated and flags incompatible ones; many marketing apps now ship their own app pixel, which Shopify recommends as the first choice.

Rebuilding tracking: from Additional Scripts to a custom pixel

This is the core of the fix. Here's a typical before: a raw tag pasted into Additional Scripts.

<!-- OLD: Additional Scripts box (not supported on the new pages) -->
<script>
  gtag('event', 'conversion', {
    send_to: 'AW-XXXX/abcd',
    value: {{ checkout.total_price | divided_by: 100.0 }},
    currency: '{{ checkout.currency }}'
  });
</script>

And the after: a custom pixel created under Settings > Customer events, then name the pixel and click Add pixel. Custom pixels run in a lax-sandbox iframe, so you load the vendor library inside the pixel itself and forward data from the event payload:

// NEW: Settings > Customer events, name the pixel, then Add pixel
// Load gtag.js inside the pixel's own sandbox, not on the page.
const tag = document.createElement("script");
tag.async = true;
tag.src = "https://www.googletagmanager.com/gtag/js?id=AW-XXXX";
document.head.appendChild(tag);
window.dataLayer = window.dataLayer || [];
function gtag() { window.dataLayer.push(arguments); }
gtag("js", new Date());
gtag("config", "AW-XXXX");

analytics.subscribe("checkout_completed", (event) => {
  const checkout = event.data.checkout;

  gtag("event", "conversion", {
    send_to: "AW-XXXX/abcd",
    value: checkout.totalPrice?.amount,
    currency: checkout.currencyCode,
    transaction_id: checkout.order?.id,
  });
});

Three things to internalize. The data comes from the event payload (event.data.checkout), never from the DOM; totalPrice.amount, currencyCode and order.id are all fields on the checkout_completed event, and Shopify notes the order ID is null on every event except this one. Second, if you use a post-purchase upsell, checkout_completed fires on the first upsell page, not the Thank you page. Third, Shopify tells you to remove existing pixel code from places like Additional Scripts before adding a custom pixel, so events aren't counted twice (Shopify Help Center).

For GA4, Shopify documents a Google Tag Manager custom pixel setup if you'd rather route everything through GTM. For Meta, prefer an app pixel from a Meta integration app over a hand-written fbq pixel. When a marketing app offers an app pixel, use it; it's less code you own and patch.

Rebuilding UI and content: Thank you and Order status blocks

Non-Plus stores can customize the new pages: Shopify's checkout extensions docs say extensions that appear after a purchase has been completed "will be available to all plans except Shopify Starter" (shopify.dev). That means an App Store app block or a small custom extension. A minimal UI extension registers its targets in its config file; this mirrors Shopify's own survey tutorial:

# shopify.extension.toml
api_version = "2026-10"

[[extensions]]
name = "post-purchase-survey"
handle = "post-purchase-survey"
type = "ui_extension"

[[extensions.targeting]]
module = "./src/ThankYou.jsx"
target = "purchase.thank-you.block.render"

[[extensions.targeting]]
module = "./src/OrderStatus.jsx"
target = "customer-account.order-status.block.render"

Note the second target: the Order status page now sits under customer accounts, so its block uses a customer-account target. Shopify's docs add that customer account UI extensions render "only on upgraded stores," so a visual customization has no replacement until the pages are upgraded.

Our build-vs-buy rule: for a typical store, a well-reviewed App Store block beats a hand-built extension on both cost and maintenance. Reserve custom checkout UI extensions for bespoke post-purchase experiences (tailored cross-sells, account linking, loyalty enrollment) where an off-the-shelf block can't deliver the UX.

Shopify Scripts and the non-Plus trap

This section only applies to Plus. Shopify Scripts stopped running on June 30, 2026, and Shopify's Help Center now says "Any Scripts that were still published on your store have been deactivated and no longer work" (Shopify Help Center). The replacement is Shopify Functions, and the plan rule is the trap for non-Plus merchants: stores on any plan can use public App Store apps that contain functions, but "only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs" (shopify.dev). Which Function API replaces which Script, the limits a Function runs under, and how to test one before it goes live are in our Shopify Functions guide.

What has no equivalent (the honest caveats)

Some legacy behavior doesn't port, and saying so up front is what separates a trustworthy quote from a painful surprise:

• Checkout UI extensions on the Information, Shipping and Payment steps remain Plus-only (shopify.dev), and so do custom apps with Functions. If those are the reason you're weighing an upgrade, our Shopify Plus vs Advanced comparison works out when the Plus fee pays for itself.
• Additional scripts can't come back. Shopify says you can only reactivate a disabled script while the pages haven't completed their upgrade; after the upgrade, you can't.
• Anything that read the page DOM has to be redesigned around the event payload, because pixels can't see the checkout page.
• A handful of niche script behaviors have no one-to-one replacement and need a rethink rather than a migration.

Set these expectations before you write the statement of work, not after.

The fix-it runbook

This is the sequence we run now that the deadline has passed:

1. Confirm the page version in Settings > Checkout, as above.
2. Rebuild on a development store first when you're writing a custom pixel or extension. Never prototype on the live store.
3. Recreate tracking as pixels and content as blocks or extensions, following the audit's classification.
4. Connect and test each pixel, then disable the matching additional script if your pages haven't upgraded yet. Shopify's additional scripts page notes that connecting the pixel first gives you a short window of duplicate events; disabling the script first avoids duplicates but risks a gap.
5. Upgrade the pages if the notice is still showing: Settings > Checkout, Review on the notice, then Upgrade.
6. Verify end to end: place a real test order and confirm Google Ads, Meta and GA4 each receive the event with the right value and currency.

Post-migration verification: a falsifiable monthly test

Don't trust "it looks fine." Each month, compare GA4 purchase events to Shopify's order count: Before peak traffic, run this test as part of our Shopify Black Friday checklist.

• A modest, stable gap on a steady-volume store means expected consent-driven reduction. Leave it.
• A large or growing gap means a real break. Re-check the pixel subscription and its customer privacy settings.

A concrete acceptance criterion beats a vibe, and it's the kind of check you can hand to a client to run themselves.

Adjacent migrations still open

Three related changes are still in motion after the August deadline:

• Legacy customer accounts are deprecated. Shopify announced on February 26, 2026 that they are no longer available to new stores, and that "a final sunset date for legacy customer accounts will be announced later in 2026" (shopify.dev changelog). As of October 12, 2026, no date has been announced. The Order status page already lives on the customer accounts surface, so plan both together.
• Order status pixels need the right subdomain. If your store uses a custom domain, Shopify says you must move customer accounts to a subdomain such as account.example.com; "otherwise, pixels and cookie consent won't work for the Order status page" (Shopify Help Center).
• Storefront script tags are next. Since October 1, 2026, apps can't create or update script tags, and Shopify plans to stop injecting them into storefronts on March 1, 2027 (shopify.dev). Any app that still loads tracking that way needs an app embed block.

What a fix realistically takes

Effort tiers, as we would scope them:

• Typical standard-plan store: app pixels plus an Order status app block, mostly configuration, low cost, doable in days.
• Mid-size store with custom upsells or affiliate logic: real development to rebuild each integration as a pixel or extension.
• Plus store that lost Scripts logic on June 30: a separate, larger Scripts-to-Functions project.

If you're pricing any of these tiers, our guide to Shopify developer cost labels each published rate by hire type and traces one checkout request through the app, Plus and Scripts paths.

DIY is sensible for the first tier. Once custom logic, several integrations or a portfolio of stores is involved, the math favors a studio that does Shopify checkout work.

How Keplaris ships this

We run the fix end to end: a tag audit, pixel and extension code checked against Shopify's current docs, a development-store rebuild, the upgrade itself where it's still pending, and the conversion-tracking check that proves events are flowing again.

If your conversions dropped after August 26 and you'd rather hand the fix to us, take a look at our Shopify E-commerce service, and see how we run Shopify engagements in our Shopify commerce case study.