Non-Plus Checkout Extensibility: Aug 26 2026 Migration

Bottom line: on August 26, 2026, every non-Plus Shopify store loses Additional Scripts, the Thank You page script box, and Order Status page scripts. If your GA4 tracking, Meta pixel, COD validator, or affiliate code lives in any of those fields, it stops firing that day. You have until August 26 to migrate to Customer Events (Web Pixels API), native channel apps, and Shopify Functions. This guide is the non-Plus playbook.

Most checkout extensibility coverage is written for Plus stores. Plus hit its deadline on August 28, 2025. Non-Plus (Basic, Shopify, Advanced) is next, and the panic is real.

I have audited 100+ Shopify stores in the last 18 months. The split is roughly 70/30 non-Plus to Plus. Almost every non-Plus store I touch has the same pattern: Additional Scripts holds three to seven snippets nobody remembers adding, Order Status has a Google Ads tag from 2022, and Thank You has a half-broken affiliate pixel. On August 26, 2026, all of it goes silent.

Below is the non-Plus migration plan I run for Basic, Shopify, and Advanced plan merchants who do not have a Plus budget and do not want one. The work is doable. The work is also not optional.

What is the August 26, 2026 deadline really about?

Shopify is removing every legacy checkout customization surface from non-Plus plans on August 26, 2026, and replacing them with Checkout Extensibility. Plus stores were forced to migrate by August 28, 2025 (per Shopify’s official upgrade guide). Non-Plus is the second wave.

On August 26, 2026, on Basic, Shopify, and Advanced plans:

• Additional Scripts (Settings > Checkout > Order processing) is removed.
• Thank You page and Order Status page additional script boxes are removed.
• checkout.liquid (already gone for Plus) stays unsupported.
• checkout.scss.liquid and any Liquid-based checkout customization is gone.

What replaces them:

• Customer Events / Web Pixels API for analytics and conversion tracking.
• Native channel apps (Google and YouTube, Meta, TikTok) for major pixels.
• Shopify Functions for cart validation, payment method filtering, delivery customization.
• Customer Account UI Extensions for post-purchase content.
• Checkout UI Extensions for in-checkout UI (Plus only for custom builds, app-installable on all plans).

The shift is from “paste any script anywhere” to “use the right API for the job.” It is more secure, faster (Shopify controls when scripts load), and breaks fewer checkouts. It is also strictly less flexible if you were doing weird DOM hacks before.

Does this affect non-Plus Shopify stores?

Yes. Every non-Plus Shopify store with anything in Additional Scripts, Thank You page scripts, or Order Status page scripts is affected. If you have ever pasted a Google Ads tag, a Meta pixel, a Klaviyo script, or a custom JS snippet into checkout settings, you are affected.

Heuristic: if you do not know what is in your Additional Scripts field, you are affected. Open it right now. Settings > Checkout and accounts > Order processing > Additional scripts. If any snippet does anything (analytics, tracking, custom logic), it stops working on August 26, 2026.

Pattern I see weekly: a Basic plan DTC brand at $40k/month with a Google Ads tag, a 2021 Meta pixel, and a Klaviyo snippet pasted by a long-gone freelancer. That store fixes itself in two hours with the native channel apps. The Advanced plan store with 11 snippets (GA4 custom events, Meta CAPI bridge, TikTok pixel, COD validator, affiliate scripts) needs the full five-week project and a developer for the COD validator and custom GA4 events.

What stops working on Basic, Shopify, and Advanced plans?

Anything that lives in a legacy script box. Anything that edits checkout.liquid. Anything that reads or writes the checkout DOM directly. Anything that depends on Liquid variables inside the checkout flow.

The full kill list, in plain English:

The pattern is simple. If it is a script tag pasted into a Shopify settings field, it dies. If it is an app installed from the App Store using the modern APIs, it lives.

What can non-Plus merchants still customize after August 26?

Plenty. Tracking via Customer Events. Cart and Checkout Validation, Payment Customization, and Delivery Customization all via Shopify Functions. Post-purchase content via Customer Account UI Extensions. Plus-tier UI extensions you can install (just not author yourself).

The non-Plus capability map (what you actually keep):

The headline: non-Plus merchants get every API surface they actually need for analytics and validation. What they do not get is the ability to write and install custom Checkout UI Extensions on their own store. They can install third-party apps that use those extensions, but they cannot deploy a custom one for their store alone.

That is the only meaningful Plus gate. Everything else has a non-Plus path.

How do I migrate additional scripts to Customer Events?

Open Settings > Customer Events. Click Add custom pixel. Paste your tracking logic, but rewrite any DOM access into the sandboxed analytics.subscribe() API. Most snippets need rewriting, not pasting.

Customer Events (Settings > Customer Events) is where Web Pixels live. Every store on every plan has it. You can add a custom pixel, name it, and write JavaScript that subscribes to standard events.

Here is a real example. This is a custom GA4 event for “begin_checkout” that previously lived in Additional Scripts:

// Custom Web Pixel: GA4 begin_checkout event
// Paste in Settings > Customer Events > Add custom pixel

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

  // Build GA4 payload from the event, NOT from DOM
  const items = checkout.lineItems.map((item) => ({
    item_id: item.variant.product.id,
    item_name: item.title,
    price: item.variant.price.amount,
    quantity: item.quantity,
    currency: checkout.currencyCode
  }));

  // Send to GA4 via Measurement Protocol
  fetch("https://www.google-analytics.com/mp/collect?measurement_id=G-XXXXX&api_secret=YYY", {
    method: "POST",
    body: JSON.stringify({
      client_id: event.clientId,
      events: [{
        name: "begin_checkout",
        params: {
          currency: checkout.currencyCode,
          value: checkout.totalPrice.amount,
          items: items
        }
      }]
    })
  });
});

Three things to notice:

1. No DOM access. Everything comes from event.data.
2. No gtag(). The pixel sandbox does not run gtag. You either use the native Google channel app or hit the GA4 Measurement Protocol directly.
3. No cookies. You use event.clientId for user stitching.

Here is a Meta pixel example for Purchase, replacing what used to be a fbq('track', 'Purchase', ...) call on the Thank You page:

// Custom Web Pixel: Meta Conversions API bridge for Purchase
// Paste in Settings > Customer Events > Add custom pixel

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

  fetch("https://your-domain.com/api/meta-capi-purchase", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      event_name: "Purchase",
      event_time: Math.floor(Date.now() / 1000),
      event_id: checkout.order?.id || event.id,
      action_source: "website",
      user_data: {
        em: checkout.email,
        ph: checkout.phone
      },
      custom_data: {
        currency: checkout.currencyCode,
        value: checkout.totalPrice.amount,
        content_ids: checkout.lineItems.map((i) => i.variant.product.id),
        contents: checkout.lineItems.map((i) => ({
          id: i.variant.product.id,
          quantity: i.quantity,
          item_price: i.variant.price.amount
        }))
      }
    })
  });
});

You proxy through your own endpoint (a small Cloudflare Worker, a Vercel function, or your existing backend) because Web Pixels cannot send the Conversions API access token directly without exposing it in client code. This is the standard pattern.

If this looks like more than you want to write, the native Meta channel app handles purchases, add-to-cart, and view-content events out of the box. Use the custom pixel only for events the native app does not cover.

How do I migrate GA4 / Meta / TikTok pixels?

Use the native channel apps first. Then add a single custom Web Pixel for any event the native apps miss. Do not rebuild from scratch what Shopify already maintains.

The non-Plus playbook is install, not build:

• Google Ads + GA4: install the Google and YouTube channel app from the App Store. It installs a managed Web Pixel that handles GA4 standard events, Google Ads conversions, Enhanced Conversions, and consent mode. Free. Maintained by Shopify and Google.
• Meta: install the Facebook and Instagram channel app. Native Web Pixel, Conversions API bridge included, automatic deduplication.
• TikTok: install the TikTok channel app. Native pixel, events API.
• Pinterest, Snapchat, Microsoft Bing: same pattern, all have native channel apps.
• Klaviyo: install the Klaviyo for Shopify app. Onsite tracking moves to its native Web Pixel.

After installing the relevant native apps, your custom Web Pixel slot is free for the one or two custom GA4 events your team actually uses (a view_size_chart event, a clicked_phone_number, etc.). Do not duplicate what the native app already sends or you double-count conversions.

After the cutover, run the Shopify CrUX Grader on your highest-traffic PDP, collection, and homepage. The native channel apps usually drop Total Blocking Time once the legacy Additional Scripts are removed; the grader confirms it on real-user field data within 28 days. If apps from the migration introduce new TBT, the Shopify App Bloat Detector ranks them so you know which one to remove first.

How do I replace a COD validator or custom checkout logic?

Shopify Functions. Specifically the Cart and Checkout Validation API for blocking checkout based on cart contents, and the Payment Customization API for hiding or showing payment methods. Both work on every non-Plus plan.

The classic non-Plus use case: block COD for orders over a certain value, or hide COD for buyers in specific postal codes. Old way was a JS snippet in Additional Scripts. New way is a Shopify Function deployed as a private app on your store.

A bare-bones Cart Validation function that blocks checkout if a buyer tries to use COD on an order over $500:

// extensions/cod-validator/src/index.js
// Cart and Checkout Validation Function

export default function (input) {
  const total = parseFloat(input.cart.cost.totalAmount.amount);
  const codSelected = input.cart.deliveryGroups.some((g) =>
    g.selectedDeliveryOption?.title?.toLowerCase().includes("cash on delivery")
  );

  const errors = [];

  if (codSelected && total > 500) {
    errors.push({
      localizedMessage: "Cash on Delivery is not available for orders over $500. Please choose another payment method.",
      target: "cart"
    });
  }

  return { errors };
}

You scaffold the app with shopify app init, write the function in extensions/cod-validator/, deploy with shopify app deploy, and install on your own store. It runs server-side on every cart change. It cannot be bypassed by disabling JavaScript. It works on Basic plan. It works on Advanced plan. It does the job your old script did, except more reliably.

This is also the API you use for “cart must contain at least one item from collection X” rules, “block checkout if address contains a PO Box,” and “require buyer to be 18+ for restricted products.”

What requires Plus and what does not?

Almost everything you need is available on non-Plus. The Plus-only items are: deploying your own custom Checkout UI Extensions, branding the checkout beyond the native editor, and B2B checkout features. Everything tracking, validation, payment, and delivery related is available on every plan.

Quick reference:

The real Plus gate is “do you need to write your own custom checkout component for this one store?” If yes, Plus. If you can use an off-the-shelf app from the App Store, non-Plus is fine.

The 5-week non-Plus migration plan

Week 1 audit. Week 2 install native apps. Week 3 build custom pixels. Week 4 migrate validation logic to Functions. Week 5 test on a development store and switch over. Backwards from August 26, that means starting by July 22, 2026 at the latest. Sooner is better because the App Store partner queue gets saturated in the final month.

The checklist I run on every non-Plus migration, with the verification artifact for each week:

Week 1: Full inventory audit. Screenshot every snippet in Additional Scripts, Thank You, and Order Status. List every installed app that touches checkout. Tag each snippet (tracking, validation, UX, dead). Delete the dead ones today. List every custom event and conversion goal in GA4 and Meta Ads Manager. Verify: a single sheet with one row per snippet, owner named, replacement API named.

Week 2: Native app installs. Install the Google and YouTube channel app, Facebook and Instagram channel app, TikTok / Pinterest / Microsoft as relevant, and Klaviyo for Shopify. Run them in parallel with legacy scripts. Verify: each native pixel fires in its real-time report (GA4 Realtime, Meta Events Manager) on a test order.

Week 3: Custom Web Pixels for the gaps. Build one custom pixel per platform under Settings > Customer Events using analytics.subscribe(). Set up a server-side proxy (Cloudflare Worker, Vercel Function) for any pixel that needs a server token. Verify: GA4 DebugView and Meta Events Manager Test Events show the custom event, and 7-day conversion counts match legacy within 5%.

Week 4: Functions for validation and payment logic. Scaffold with shopify app init, write the Function in extensions/, deploy with shopify app deploy, install on store. Verify: edge-case test orders on a development store (COD over threshold blocked, restricted postal code blocked, payment method hidden).

Week 5: Cutover and cleanup. Duplicate the live theme. Confirm every pixel fires in checkout preview. Delete every snippet from Additional Scripts, Thank You, and Order Status (keep the Week 1 screenshots for rollback). Verify: GA4 and Meta dashboards stay clean for 14 consecutive days post-cutover.

The audit (Week 1) and native installs (Week 2) are usually solo work. Custom Web Pixels and Functions (Weeks 3 and 4) are where most non-Plus merchants stall. Hire for those weeks specifically, not the whole project.

For background on why checkout migration matters for conversion rate, see my Shopify checkout optimization guide. For the GA4 tracking issues that often surface during this migration (especially cross-domain), the GA4 tracking broken fix guide walks through the exact debug flow. The conversion leaks guide has the dollar math on broken tracking, and the cart abandonment causes piece covers the friction points worth fixing while you have the checkout open. For a real markets-aware checkout fix on a non-Plus store, see the Everly Markets FOUC case study.

The August 26, 2026 deadline is firm. There is no extension on the way. Every non-Plus merchant who does nothing wakes up that day with broken tracking, broken validation, and silent revenue leak. The five-week plan above is enough time if you start by mid-July at the latest.

If you want me to run the Week 1 audit on your Basic, Shopify, or Advanced plan store and tell you exactly what breaks on August 26, that is what the diagnostic call is for.

The takeaway

• Audit every script in Settings, Checkout, Order processing this week. Screenshot it before anything changes.
• Install the native Google, Meta, TikTok, Pinterest, and Snapchat channel apps before touching custom pixels.
• Move validation logic (COD, regional gateway hiding, B2B gating) to Shopify Functions, which work on every plan.
• Verify GA4 and Meta dashboards on a duplicate theme for 7 days before you delete the legacy scripts.
• Cut over by July 22 at the latest. App Store partner queues saturate in the final month before the deadline.

Need help migrating your Basic/Advanced Shopify checkout before August 26? Book a free 30-minute migration audit.