Shopify Checkout Extensibility: What Changed and How to Use It
For years, Shopify Plus merchants had a powerful but unwieldy tool at their disposal: checkout.liquid. It gave brands near-complete control over the checkout experience - custom layouts, bespoke logic, and heavily tailored flows. It also came with significant trade-offs: maintenance overhead, upgrade friction, and the constant risk of breaking changes when Shopify rolled out platform improvements.
In August 2024, Shopify officially sunset checkout.liquid in favour of Checkout Extensibility - a new framework that fundamentally changes how merchants customise their checkout. For brands that relied heavily on checkout.liquid, this was a significant shift. For those looking to build more resilient, scalable checkout experiences, it represents a meaningful step forward.
Why Shopify made the change
Shopify's checkout is one of the highest-converting in eCommerce, processing billions of dollars in transactions annually. But checkout.liquid created a tension: the more a merchant customised their checkout, the harder it became for Shopify to roll out improvements across the platform without risking those customisations.
Every time Shopify wanted to introduce a new payment method, improve accessibility, add fraud detection, or optimise for speed, they had to account for the thousands of merchants running bespoke checkout.liquid templates. This slowed down innovation for everyone.
Checkout Extensibility solves this by introducing a clear contract between Shopify and the merchant. Shopify controls the core checkout experience - the layout, security, performance, and payment processing - while merchants extend it through a defined set of APIs, UI extensions, and Shopify Functions. Think of it as moving from renovating the foundations of a house to decorating the rooms: you get meaningful control over the experience without risking structural integrity.
What Checkout Extensibility actually includes
The framework is built on three main pillars, each serving a distinct purpose in how merchants can tailor their checkout.
Checkout UI Extensions allow merchants to add custom interface elements at specific points in the checkout flow. These are rendered in a secure, sandboxed environment, which means they can't break the core checkout or introduce security vulnerabilities. Common use cases include trust badges, upsell offers, gift messaging fields, loyalty point displays, and custom delivery instructions.
The key difference from checkout.liquid is that these extensions are injected at predefined extension points rather than replacing the entire template. Shopify determines where extensions can appear - before and after line items, in the shipping step, on the thank-you page - and merchants build within those boundaries.
Shopify Functions replace the Script Editor and allow merchants to create custom backend logic that runs directly on Shopify's infrastructure. This is where things get technically interesting. Functions can power custom discount logic (such as tiered discounts based on cart composition), delivery customisations (hiding or reordering shipping options based on product type or customer location), and payment customisations (showing or hiding payment methods based on order value or customer segment).
Because Functions run server-side on Shopify's infrastructure, they're fast, reliable, and scale automatically - there's no external server to maintain or worry about during peak traffic periods like BFCM.
Branding API and Checkout Editor give merchants visual control over the checkout's look and feel without writing code. Colours, typography, logos, corner radius, spacing - all of this is configurable through the Shopify admin. For brands where checkout consistency with the rest of the storefront is important (which is most brands), this provides a straightforward way to maintain visual coherence.
What this means in practice
For most Shopify Plus merchants, the migration to Checkout Extensibility represents both a simplification and, in some cases, a rethinking of how checkout customisations are implemented.
The straightforward wins. If your checkout.liquid customisations were primarily visual - custom colours, brand fonts, a trust badge below the payment form - the migration is relatively seamless. The Checkout Editor and Branding API handle most of these requirements out of the box, often with less code and maintenance than before.
The considered adjustments. If you were using checkout.liquid for custom logic - showing different content based on cart contents, dynamically adjusting shipping options, or applying complex discount rules - you'll need to rebuild this using Shopify Functions and Checkout UI Extensions. The good news is that these are purpose-built for exactly these use cases. The architecture is more robust, the performance is better, and you won't need to worry about your customisations breaking when Shopify ships updates.
The genuine limitations. There are things checkout.liquid could do that Checkout Extensibility currently cannot. Full layout control, arbitrary HTML injection, and some highly specific DOM manipulations aren't possible within the sandboxed extension model. For the vast majority of merchants, these limitations won't matter - the available extension points cover the most common and commercially impactful use cases. But for brands with genuinely unique checkout requirements, it's worth mapping out exactly what you need against what's currently supported.
Shopify continues to expand the available extension points and APIs, so capabilities that aren't available today may well be in the near future. Keeping a close watch on the Shopify changelog is worthwhile.
How to approach the migration
If you haven't yet migrated from checkout.liquid, the practical advice is to start with an audit. Document every customisation in your current checkout - what it does, why it exists, and what business impact it has. Some customisations were added years ago and may no longer be relevant. Others may be critical to your conversion flow.
From there, map each customisation against the available Checkout Extensibility capabilities. In our experience, the majority of customisations translate well. The ones that require more creative thinking are typically those that relied on unrestricted DOM access - and even then, there's usually an alternative approach that achieves a similar outcome within the new framework.
It's also worth taking the migration as an opportunity to clean house. Checkout is the most commercially sensitive part of your store, and every unnecessary element adds friction - however small. If a customisation can't demonstrate clear value, it probably shouldn't make the journey to the new framework.
Looking ahead
Checkout Extensibility isn't just a technical migration - it's a signal of where Shopify is heading as a platform. The move toward defined extension points, server-side logic, and sandboxed UI components reflects a broader philosophy: give merchants the flexibility they need while maintaining the performance, security, and reliability that their customers expect.
For brands that embrace this approach, the payoff is a checkout that's faster, more maintainable, and automatically benefits from every improvement Shopify ships to the core platform. That's a meaningful competitive advantage, especially during the moments that matter most - like a customer deciding whether to complete their purchase.