What Shopify Checkout Extensibility actually unlocks (and what's still off limits)

Checkout.liquid sunset happened in August 2024. If you're still on it, Shopify has been nudging you toward Checkout UI Extensions for two years. If you've already migrated, you've discovered that the replacement is more capable in some ways and more constrained in others.

Here's an honest account of where things stand.

What Checkout.liquid was actually doing for you

Before unpacking the new world, it helps to be clear about what the old one was providing.

For most Shopify Plus stores, checkout.liquid was being used for a fairly narrow set of things:

• Custom branding beyond what the theme editor allowed
• Injecting additional fields (VAT number, purchase order reference, gift messaging)
• Surfacing custom upsells or product offers at checkout
• Integrating third-party trust signals (security badges, guarantees)
• Displaying loyalty points balances or reward eligibility

A smaller number of stores were using it for more structural changes: custom payment method logic, address validation overrides, or complex B2B flows. Those cases are worth examining separately.

What Checkout UI Extensions handle well

The extension system is genuinely good for a well-defined class of problems.

Branding and visual customisation. The checkout editor in the Shopify admin has improved significantly. Typography, colour, logo placement, and layout choices now cover most branding requirements without code. Custom CSS isn't available (by design), but the editor variables give you enough control for most cases.

Additional form fields. CheckoutFields API lets you capture custom data at checkout — order notes, gift messages, B2B reference numbers, consent checkboxes. The data is stored on the order as attributes. This used to require Checkout.liquid; it's now a first-class extension capability.

Custom blocks and banners. You can inject content at defined positions in the checkout flow: above the order summary, below the payment button, in the thank you page, in the order status page. Trust signals, shipping reassurances, loyalty points displays — all manageable.

Upsell and cross-sell offers. productOffers API lets you surface post-purchase offers (on the order status page) and pre-purchase offers within the checkout. The UX is constrained — Shopify controls the interaction pattern — but it covers the core use case.

What you still can't do

This is where many merchants get surprised.

You cannot write arbitrary JavaScript that runs on the checkout page. Extensions run in a sandboxed environment with a defined API surface. If you're used to injecting scripts via checkout.liquid, that pattern is gone. Third-party analytics that rely on checkout page script access need to be integrated via Shopify's Pixels API or pixel extensions instead.

You cannot modify the core checkout layout structure. The positions where you can inject content are defined by Shopify. You can't reorder the steps, remove built-in fields, or fundamentally change how the checkout flows. The extension system is additive, not structural.

Custom payment UI is not possible through extensions. Payment methods and their presentation are controlled by Shopify. If you need custom payment method ordering or conditional payment method display based on cart contents, Shopify Functions (specifically payment-customization) is the right tool — but it's logic, not UI.

Full custom checkout design is off the table. If your brand requirements demand a checkout that looks materially different from what Shopify's checkout editor produces, Checkout UI Extensions won't get you there. Headless with a custom checkout implementation (using Hydrogen or another framework against the Storefront API) is the only path to that level of control — and comes with significant complexity tradeoffs.

Where Shopify Functions change the picture

Checkout UI Extensions handle presentation. Shopify Functions handle logic.

If your Checkout.liquid implementation was doing conditional discount logic, custom validation, or payment/shipping rules, Functions are the right layer for those requirements:

• cart-transform — rewrite cart line items before checkout: bundle unpacking, custom line item properties, free gift logic
• discount — programmatic discount logic beyond what automatic discounts support
• payment-customization — hide, rename, or reorder payment methods based on cart context
• shipping-customization — same for shipping methods
• fulfillment-constraints — restrict fulfillment based on product or location rules

The key constraint: Functions are pure computation. They receive input, return output, and have no access to external APIs during execution. If your discount logic depends on a real-time loyalty points balance from a third-party system, you can't call that API from within a Function. You need to pre-fetch the data and store it as cart attributes, then reference those attributes in the Function.

The honest assessment

For most Shopify Plus stores, the migration from Checkout.liquid to the extension system is manageable and the new system is genuinely more maintainable. You lose the anything-goes flexibility of injecting arbitrary HTML and scripts, and you gain a system with defined APIs, a proper theme editor, and Shopify's hosting and versioning.

Where the system genuinely falls short is at the edges: stores with complex custom checkout UI requirements, stores with integration patterns that rely on checkout page script access, and stores with payment or shipping logic that depends on real-time external data.

If you're in one of those categories, the honest answer is that the extension system was not designed for your use case. The question is whether to solve it within the Shopify system (usually with significant architectural adjustment) or to move the checkout outside the standard Shopify flow entirely.

Most stores aren't in those categories. The migration is overdue if you haven't done it.