Shopify Scripts Sunset on June 30, 2026: The Migration Checklist for Shopify Functions

Shopify Scripts stop running June 30, 2026. Use this Shopify scripts to functions migration checklist to inventory, rebuild, and verify before the deadline.

Shopify Scripts Sunset on June 30, 2026: The Migration Checklist for Shopify Functions

Shopify Scripts officially stop running on June 30, 2026, and Shopify has confirmed there are no extensions. If your store still relies on Script Editor for discounts, shipping rules, or payment customizations, you have until that date to rebuild every one of them as a Shopify Function or watch the logic silently fail at checkout. This Shopify scripts to functions migration guide walks through inventory, common rewrites, the new development model, verification steps, and what happens if you miss the cutoff.

Why Scripts are going away

Shopify Scripts ran on a Ruby-based engine inside the Script Editor app, available only to Shopify Plus stores. The platform announced deprecation in 2023 and set the final sunset for June 30, 2026 to coincide with the full rollout of checkout extensibility. Functions are the replacement: serverless code units written in JavaScript, TypeScript, or Rust, deployed through the Shopify CLI, and executed inside Shopify's Oxygen runtime.

The practical differences:

Functions run on the new checkout, not the legacy /checkout flow.
Functions are versioned, testable, and deployable through Git, not a textarea inside the admin.
Functions can be installed as part of a Shopify app, including custom apps your team owns.
Functions have explicit input queries (GraphQL) and typed outputs, so failures surface in logs rather than vanishing into a black box.

Step 1: Inventory every active Script

Open Script Editor in your store's admin and export the current state. For each Script, record:

Script title and Script ID
Type (line item, shipping, or payment)
Whether it's currently published
The discount, shipping, or payment logic it implements
The Ruby source code (copy it into version control as reference)
Any merchant-facing names customers see on the cart or checkout

If you have multiple Plus stores under one organization, do this per store. Scripts do not migrate automatically.

Step 2: Map each Script pattern to a Function

Most Scripts fall into a handful of patterns. Here is how the common ones translate.

Line item discount Scripts

A Script that gave 10% off all "summer" tagged products, or BOGO logic, or a tiered discount based on cart subtotal, becomes a Product Discount Function or Order Discount Function depending on whether you discount specific lines or the whole cart. You write a run function that receives the cart as input and returns a list of discount operations. Shopify's @shopify/shopify_function packages provide the type definitions.

Shipping Scripts

Free shipping for orders over a threshold, regional surcharges, hiding specific shipping methods for specific products: all of this is now a Delivery Customization Function. The Function returns rename, hide, or move operations against the available shipping rates. There is no longer a way to rewrite shipping cost arithmetic the way Scripts could; if you need price adjustment, configure it at the rate level and use the Function only to filter and reorder.

Payment Scripts

Hiding "Cash on Delivery" for B2B orders, reordering payment methods, or suppressing a payment provider above a cart value, is a Payment Customization Function. Same operations pattern: hide, rename, move.

Combined logic

Scripts often did several things in one block. Functions are scoped to one customization type each. Expect to split a single Script into two or three Functions. This is a feature, not a bug: each one is easier to debug.

Step 3: Set up your development environment

You need a working local environment before you write a single line.

Node.js 18 or higher
The Shopify CLI (latest version)
A Partner organization with access to the target store
A custom app created in the Partner dashboard (or use an existing one)

Run shopify app init to scaffold a project, then shopify app generate extension and pick the Function type that matches your Script. The CLI creates the directory structure, the GraphQL input query, and a starter run.ts (or src/lib.rs for Rust).

TypeScript or Rust?

TypeScript is faster to read for most teams. Rust compiles to smaller, faster WebAssembly and has stricter type guarantees. For typical discount and shipping logic, TypeScript is fine. For complex Functions that handle large carts and run on every cart update, Rust can save execution time and stay under Shopify's instruction count limits.

Step 4: Rewrite, test, deploy

For each Function:

1. Define the input query in input.graphql to pull only the cart fields you need (cart lines, attributes, customer tags, discount allocations).

2. Implement the run function. Return the operations as a typed FunctionRunResult.

3. Write unit tests against sample input JSON. The shopify app function run command executes your Function against a local input file and prints the output.

4. Run shopify app deploy to push to the store. This creates a new app version that must be released.

5. In the admin, install the app on the target store and activate the Function under Settings, Discounts, Shipping, or Payments depending on the type.

Step 5: Verify in production

Before flipping any live customer traffic onto the new Function:

Place test orders covering every branch of the logic. Tagged customers, edge-case cart totals, multi-line carts, draft orders, gift card purchases, subscription items.
Compare the order totals against what the legacy Script produced. If they differ by even a cent, find out why before you ship.
Check Function logs in the Shopify admin under Settings, Custom data, then the Functions tab. Errors are listed there with the input that triggered them.
Disable the corresponding Script in Script Editor only after the Function has run cleanly for at least 48 hours of real traffic.

What changes for your team

If your team is used to editing Ruby inside the admin and clicking save, the new model will feel heavier on day one. The trade-off is real version control, code review, and a deploy pipeline. A few things to plan for:

Source control: every Function lives in a Git repo. Decide who has access and how releases get tagged.
Deploys: Functions deploy via the CLI, which means they can be wired into CI. Most stores can keep things simple and deploy manually for now.
Two environments: use a development store to test Functions before deploying to the production Plus store. Shopify's Partner accounts support unlimited dev stores.
Documentation: write down what each Function does. Six months from now, no one remembers.

What happens if you miss June 30, 2026

If a Script is still active on July 1, 2026, it does not error loudly. It just stops executing. The cart and checkout will skip past the logic as if the Script were not there. That means:

Discounts you expected to apply will not apply. Customers pay full price on items that should have been discounted, or your store loses margin on items that should have been free.
Hidden shipping methods will reappear. Customers can pick a method you intended to suppress.
Hidden payment methods will reappear. The same applies to reorders and renames.

There is no graceful fallback. There is no banner in the admin. The only signal is your order data drifting.

Contingency plan

If June 30 is approaching and you have Scripts you cannot rebuild in time:

1. Identify which Scripts are most material to revenue or operations. Discount Scripts that drive promotions are usually the most urgent.

2. For low-priority Scripts, decide whether the underlying business rule is still needed. Sometimes the answer is no.

3. For shipping and payment Scripts, look at whether the same outcome can be achieved with native Shopify settings (shipping zone configuration, payment method ordering in Settings).

4. If you genuinely cannot rebuild in time, plan for the post-deadline state and communicate it to operations, finance, and customer service so no one is surprised when totals look different.

Frequently asked questions

When exactly do Shopify Scripts stop working?

Shopify Scripts stop executing on June 30, 2026. Shopify has confirmed there will be no further extensions. Scripts remain visible in the admin after that date but no longer apply at checkout.

Are Shopify Functions available on all Shopify plans?

Functions are available on all Shopify plans, including non-Plus stores. Scripts were Plus-only. This is a real expansion of what merchants can customize at checkout.

Can I keep using Script Editor until June 30, 2026?

Yes, Script Editor remains functional until the sunset date. Use that runway to migrate, not to delay. Running Scripts and Functions in parallel during testing is supported.

Do Functions work on the legacy checkout?

No. Functions only run on the checkout extensibility version. If your store is still on legacy checkout, migrating to the new checkout is a prerequisite. Shopify Plus stores are already required to be on extensibility by the August 2025 cutoff, so this should be handled.

How much does it cost to rebuild Scripts as Functions?

If you have one or two simple Scripts, a developer comfortable with TypeScript can typically rebuild them in a day. Complex stores with a dozen interlocking Scripts can run into weeks of work, especially the verification phase. Budget for testing time, not just code time.

Will third-party apps replace Scripts I rely on?

Some apps offer pre-built Functions for common use cases like volume discounts, BOGO, and shipping rate display logic. If your Script logic is generic, an app may be faster than custom code. If it encodes business rules specific to your store, custom Functions are the right call.

Bottom line

You have until June 30, 2026 to migrate every active Shopify Script to a Shopify Function. The work is straightforward but not trivial: inventory what you have, rebuild each Script as a Function in the new development model, verify in production, and disable the old Scripts only after the new Functions are proven. Miss the date and the logic does not error, it just stops applying, which is worse than a hard failure.

*Want help with your Shopify scripts to functions migration? Book a call with us.*

Shopify Scripts Sunset on June 30, 2026: The Migration Checklist for Shopify Functions