The Complete Guide to Shopify Checkout Extensibility

Key takeaways

• Shopify checkout extensibility is the framework that replaced checkout.liquid. It splits checkout customization into structured tools: Checkout UI extensions, Shopify Functions, the branding API, and web pixels.
• Plus stores lost checkout.liquid, additional scripts, and script tags on the Thank you and Order status pages on August 28, 2025, with automatic upgrades starting January 2026.¹²
• Non-Plus stores have until August 26, 2026 to upgrade the Thank you and Order status pages.³ Shopify Scripts stop working after June 30, 2026.¹
• Custom code goes into sandboxed extensions and pixels now, not raw JavaScript in a checkout field. That is more limited, and it is the trade for a faster, safer checkout.
• The migration is real theme and app work. A draft-first tool like Fudge handles the storefront edits around it without you hand-writing everything.

Shopify checkout extensibility is the current, supported way to customize the Shopify checkout. It is not a single feature. It is a set of building blocks - Checkout UI extensions, Shopify Functions, a branding API, and web pixels - that each own a slice of the checkout that checkout.liquid used to cover in one file.

This guide is the map. It covers what checkout extensibility is, why Shopify deprecated checkout.liquid, the deadlines that matter right now, each building block and where it fits, extension targets, the Thank you and Order status pages, how to upgrade, and the limits you should plan around. Each section links down to a focused guide if you want to go deeper.

Every date and version below is cited to a Shopify primary source. Checkout deadlines have moved before, so verify against the linked Shopify pages before you plan a migration around them.

Why you can trust us

We have been in the Shopify space for over four years and have worked with hundreds of stores.

Jacques, our CTO, has more than 15 years of development experience and has built and migrated storefronts for many Shopify brands, including checkout work.

We built Fudge - an AI-native Shopify page builder and store editor with a 5.0 rating on the Shopify App Store and a Built for Shopify badge. We are biased toward our own product, and we say where it fits and where it does not.

What is Shopify checkout extensibility?

Checkout extensibility is a structured framework for customizing checkout through Shopify-approved APIs instead of arbitrary code.

The old model let you drop any JavaScript, Liquid, or third-party script into the checkout through checkout.liquid and the additional scripts field. That was flexible and fragile. A slow tracking script or a broken snippet could degrade or break the highest-value page on the store.

The new model divides that surface into defined tools:

• Checkout UI extensions for interface changes.
• Shopify Functions for backend logic like discounts, delivery, payment, and validation.
• The branding API for styling.
• Web pixels for tracking and analytics.

Each tool runs inside Shopify’s own rendering and sandboxing. You get less raw freedom and a checkout that stays fast, upgradeable, and consistent across web and the Shop app.

Checkout extensibility vs checkout.liquid

The point of the table: nothing was removed without a replacement. The work is mapping each old customization to its new tool.

Why did Shopify deprecate checkout.liquid?

Three reasons drove it: performance, security, and upgradeability.

checkout.liquid let merchants edit the checkout directly, which meant Shopify could not safely change the checkout underneath them without risking every customization. Injected scripts also ran with full access to the page, including a page handling payment and personal data.

Checkout extensibility fixes that by putting customizations behind versioned APIs and sandboxes. Shopify can then ship checkout improvements - conversion features, One Page Checkout, accessibility fixes - without breaking your code, because your code talks to a stable interface rather than the raw page.

The deadlines that matter in 2026

This is the part to get right, because missing a date means Shopify removes customizations for you.

A few notes on reading this table.

For Plus stores, the checkout.liquid steps for Information, Shipping, and Payment were already unsupported ahead of the Thank you and Order status sunset.¹ The August 28, 2025 date and the January 2026 auto-upgrade apply to the Thank you and Order status pages specifically.¹²

For non-Plus stores, the Thank you and Order status pages are the surface affected, and the date is August 26, 2026.³ Anything living in the additional scripts field on those pages - conversion tags, pixels, custom snippets - needs a new home before then.

Shopify Scripts is a separate deadline. Discount, shipping, and payment logic built as Scripts keeps running only until June 30, 2026, after which that logic moves to Shopify Functions.¹

The building blocks of checkout extensibility

Four tools replace what checkout.liquid did. Here is what each one owns.

Checkout UI extensions

Checkout UI extensions add custom interface and logic into the checkout, Thank you, and Order status pages at defined placements.⁴

They are built with Shopify’s web components - buttons, text, form inputs, checkboxes - combined with layout primitives like stack, grid, and section.⁴ You render them at specific targets rather than editing the page directly, and they read checkout data through target APIs: buyer identity, cost, line items, attributes, and metafields.⁴

Common uses: custom fields (delivery notes, gift messages), trust content, upsells, and content banners. The full checkout steps (Information, Shipping, Payment) accept UI extensions on Plus; the Thank you and Order status pages accept them on all plans.⁴

The current Checkout UI extensions API version is 2026-04.⁴

Related, for label and field changes at checkout: how to change checkout field labels in Shopify.

Shopify Functions

Shopify Functions customize backend business logic - the decisions the checkout makes, not what it looks like.⁵

Function types cover the areas Scripts used to handle and more:⁵

• Discounts - custom discount types and combinations.
• Delivery customizations - rename, reorder, or hide delivery options.
• Payment customizations - hide or reorder payment methods.
• Cart and checkout validation - block checkout when conditions are not met.
• Order routing, pickup points, and bundles.

Functions compile to WebAssembly and run on Shopify’s infrastructure.⁵ Templates exist for Rust and JavaScript, and Shopify recommends Rust as the most performant choice so functions do not fail on large carts.⁵ They run without network or filesystem access, which is what keeps them fast and predictable inside checkout.

This is the direct replacement for Shopify Scripts. If you have Scripts, they are the first thing to port before the June 30, 2026 date.¹

Related: adding custom JavaScript in Shopify covers where storefront JS still fits versus where Functions now own the logic.

The branding API

The branding API styles the checkout through structured design tokens rather than free CSS.

It works through the checkoutBrandingUpsert mutation in the GraphQL Admin API, with a designSystem that sets foundational colors, typography, corner radius, and spacing, and a customizations object that styles specific components.⁶ Styles apply across checkout, checkout UI extensions, and customer account pages together, not per page.⁷

One constraint to plan around: advanced checkout styling through the branding API is available only to Shopify Plus merchants.⁷ Non-Plus stores customize through the checkout editor’s colors, fonts, and logo settings.

Related, for adding reassurance content at checkout: how to add trust badges to Shopify checkout.

Web pixels

Web pixels replace the additional scripts field for tracking.

The Web Pixels API subscribes to customer events - page views, product views, add to cart, checkout completed - inside a sandbox, so tracking observes events without touching the checkout itself.⁸ App pixels run in a strict sandbox and can pull settings configured through the Admin API; custom pixels run in a lax sandbox and need no boilerplate.⁸

This is where Google Ads conversion tags, Meta pixels, GTM, and analytics move. Pasting them into the old additional scripts field stops working at each store’s deadline.¹³

Understanding extension targets

Targets decide where a UI extension appears and how it behaves.⁴ There are three kinds:

Static and block targets cover most visible customizations. The difference is control: static targets render where the target is defined, while block targets let the merchant choose the position in the checkout editor.⁴

A single extension can register more than one target, which is how one app can add both a field and the logic that reacts to it.

Thank you and Order status page extensibility

The Thank you and Order status pages are where most non-Plus stores feel this change, because that is where their tracking and post-purchase content lived.

Both pages are now customized through the checkout and accounts editor with UI extensions and web pixels, not checkout.liquid or additional scripts.²³ UI extensions can show a personalized message, a survey, or post-purchase content, with read access to order metafields.⁴ Tracking that used to sit in additional scripts moves to app pixels so events keep firing.²

For a store on Basic, Shopify, or Advanced, the practical checklist before August 26, 2026:³

1. Find every tag in the additional scripts field (conversion, remarketing, analytics).
2. Recreate each as an app pixel or custom pixel.
3. Rebuild any post-purchase content as a UI extension on the Thank you page.
4. Verify events fire in a test order before the deadline.

If you do nothing, Shopify upgrades the store for you and the legacy customizations do not carry over.²³

How to upgrade from checkout.liquid

The upgrade is a mapping exercise. Take each thing the old checkout did and move it to the tool that now owns it.

A workable order of operations:

1. Inventory the old checkout. List every customization, script, and app touching checkout, Thank you, and Order status.
2. Sort by tool. Assign each item to UI extension, Function, branding, or pixel.
3. Check your apps first. Many apps already ship checkout-extensibility versions. Upgrading the app is often faster than rebuilding custom code.
4. Rebuild custom pieces as extensions. Scaffold with the Shopify CLI and test against a development store.
5. Move Scripts to Functions early. That deadline (June 30, 2026) comes before the non-Plus page deadline.¹
6. Verify with a real test order before you rely on it.

For the Plus-specific path, including where limited checkout editing still applies, see how to modify checkout.liquid in Shopify Plus.

Testing checkout extensions

Checkout is the page you least want to break, so test before you ship.

• Development stores. Build and preview extensions against a free development store, not production.
• Shopify CLI preview. shopify app dev serves your extension so you can see it in a real checkout session before deploying.
• Test orders. Place a real order end to end, including the Thank you and Order status pages, and confirm pixels fired.
• Draft themes for surrounding storefront edits. Checkout content often sits next to cart and product changes; keep those in a draft until you publish.

For upsell and cross-sell logic that touches cart and checkout together, see how to add upsells in Shopify cart. Conversion changes around checkout are worth measuring; our Shopify CRO guide covers what to test and how.

Limits and constraints to plan around

Checkout extensibility is more restrictive than checkout.liquid by design. Know the edges before you promise a build.

• No arbitrary code in checkout. You work through defined targets and APIs. If there is no target for a placement, you cannot render there yet.
• Full checkout customization is Plus-only. UI extensions on the Information, Shipping, and Payment steps, and the branding API, are Shopify Plus features.⁴⁷ Non-Plus stores customize the Thank you and Order status pages plus editor-level styling.
• Functions run sandboxed. No network or filesystem access, and performance matters on large carts, which is why Shopify recommends Rust.⁵
• Branding is checkout-wide. Styles apply across the checkout experience together, not page by page.⁷
• APIs are versioned. Extensions target a specific version, currently 2026-04 for Checkout UI extensions, and you upgrade deliberately.⁴

These limits are the trade. In exchange you get a checkout that stays fast, secure, and upgradeable, which the old model could not guarantee.

Where Fudge fits around checkout work

Checkout extensibility is developer work: scaffolding extensions, writing Functions, wiring pixels, testing against dev stores.

The storefront around checkout - landing pages, cart content, product pages, trust sections, seasonal campaigns - is where a lot of the conversion work actually happens, and most of it does not need a developer.

That is the job Fudge does. It runs inside the Shopify admin, works from prompts instead of code, and keeps every change as a draft you preview before publishing. It outputs native Liquid, JS, and CSS into your theme, so there is no lock-in. For the merchant-facing edits that surround a checkout migration - the pages and content you would rather not hand-build - the store editor covers them while your team handles the checkout extensions.

The two are different layers. The extension APIs own the checkout; a draft-first editor owns the storefront around it.

Summary

Checkout extensibility replaced one flexible, fragile file with four defined tools: UI extensions for interface, Functions for logic, the branding API for style, and web pixels for tracking. You trade raw freedom for a checkout that stays fast and upgradeable.

The dates are the urgent part. Plus stores were upgraded through 2025 and into January 2026.¹² Shopify Scripts stop after June 30, 2026.¹ Non-Plus stores have until August 26, 2026 to move the Thank you and Order status pages.³ Verify each against the Shopify pages linked below before you plan around them, since checkout timelines have shifted before.

Map every old customization to its new tool, port Scripts to Functions first, move tags to pixels, and test with a real order. That is the whole migration.

FAQ

Related posts

The State of Shopify Performance in 2026

20 Jul 2026

Fix the 6 Most Common Accessibility Failures in Your Shopify Theme

18 Jul 2026

Shopify Updates July 2026: What Actually Matters for Merchants

16 Jul 2026