Checkout Extensibility

What replaced checkout.liquid and Shopify Scripts?

For years, Shopify Plus stores customized checkout by editing a checkout.liquid file and running Ruby-based Shopify Scripts for discounts, shipping and payment rules. Both are gone. The dates that matter:

• August 13, 2024: checkout.liquid stopped working on the information, shipping and payment steps for Plus stores. Stores that had not upgraded fell back to a standard checkout.
• August 28, 2025: checkout.liquid, additional scripts and script tags stopped running on the Thank you and Order status pages for Plus stores. The Additional scripts box in settings became read-only.
• April 15, 2026: Shopify Scripts could no longer be edited or published.
• June 30, 2026: Shopify Scripts stopped running.
• August 26, 2026: the deadline for stores on other plans to upgrade their Thank you and Order status pages.

As of October 2026, every store runs on Checkout Extensibility. Any quote or plan that still mentions checkout.liquid or Scripts describes code that will not run.

How does Checkout Extensibility work?

It has four parts, and most projects use more than one.

• Checkout UI extensions add interface at published targets: a delivery note field, a gift message, a trust banner, an upsell block or a delivery date picker. They are built with Shopify's components and inherit the store's branding.
• Shopify Functions handle logic that runs on the server: discounts, which delivery and payment methods appear, cart and checkout validation, bundles through cart transform, fulfillment constraints and order routing.
• Branding covers colors, fonts, corner radius, logo and layout. The checkout and accounts editor handles the basics. The Checkout Branding API goes further and is available on Shopify Plus.
• Web pixels replace the tracking code that used to live in additional scripts. Google Tag Manager, ad pixels and analytics now load as app pixels or custom pixels from Settings > Customer events.

Changes are tested on draft checkout configurations. Only one configuration is live at a time, and publishing a draft swaps it with the live one, so you can roll back.

What can you customize on each Shopify plan?

• Extensions on the information, shipping and payment steps: Shopify Plus only.
• Extensions on the Thank you and Order status pages: Basic and above.
• The checkout and accounts editor: Basic and above.
• Functions from public App Store apps: every plan.
• Custom Functions in your own private app: Plus only.
• Checkout Branding API: Plus only.

For a store on Advanced, this usually means rules come from public apps and the visible checkout changes only after the order is placed.

What are the technical limits?

• A checkout UI extension's compiled bundle can be at most 64 KB.
• Extensions run in a sandboxed Web Worker. They have no access to the page's DOM, the checkout HTML or payment details, and need an explicit network access setting to call outside services.
• Up to 3 extensions can sit on one block target, with up to 20 merchant settings each.
• From API version 2025-10, extensions use Polaris web components, and Shopify recommends Preact over React.
• A store can have up to 25 active Functions each for discounts, delivery customization, payment customization and validation.
• Each Function run is limited to 11 million instructions, 128 kB of input and 20 kB of output for carts of up to 200 lines.
• Pixels can't change or read the page. Anything a shopper sees has to be an extension.

How do you move a checkout onto Checkout Extensibility?

Most stores are already on it by force. The work now is rebuilding what was lost or never rebuilt properly.

1. List every checkout rule and customization the store had: hidden payment methods, freight rules, minimum order values, custom fields, tracking.
2. Ask what each one earned. Some exist only because nobody removed them.
3. Map each remaining item to a Shopify setting, a public app, a UI extension, a Function or a B2B setting.
4. Move tracking into web pixels and check that purchase events still reach GA4 and ad platforms without double counting.
5. Build on a draft configuration and a development store.
6. Test with real carts: discounts, B2B accounts, markets, express wallets and failed payments.
7. Publish, then watch conversion rate and checkout errors for the first week.

Does it affect conversion and performance?

Checkout pages aren't indexed, so this isn't an SEO question. It is a conversion and reliability question. Because Shopify owns the page, stores get its one-page checkout, express wallets and speed work without a developer reapplying changes. Each extension still adds work to the page that matters most, and a Function that fails or runs slowly can hide a shipping or payment method for real customers. Fewer, well-tested extensions beat many small ones.

What does this look like on a real store?

For a private B2B client we moved to Shopify Plus, with more than 120,000 products, we built a checkout extension that recommends items from the same collection, then from the same product type and vendor, with quantity steppers. Buyers add the supplies they forgot without leaving checkout, so reorders happen inside it rather than in a second order.

What are the common mistakes?

• Designing a checkout mockup that assumes full layout control.
• Rebuilding features Shopify now ships, such as express wallets, address autocomplete and trust messaging.
• Quoting discount logic as Scripts, which stopped running on June 30, 2026.
• Moving tracking last and losing purchase events in analytics.
• Editing the live configuration instead of testing on a draft.
• Expecting a custom Function on a non-Plus plan.

When do you need a developer?

Editor branding and installing a public app are admin work. Custom extensions, private Functions, B2B checkout rules and pixel migrations are not, because a mistake there costs orders, not just looks. Our Shopify development team starts with the audit in step one, then builds only what still earns its place in checkout.