If your Shopify Plus store uses Scripts for volume discounts, conditional free shipping, or custom payment method logic, you are running on borrowed time. Shopify Scripts is being retired at the end of June 2026. After that date, your Scripts will stop working and any discounting, shipping, or payment logic they handle will break.

This is not a gradual deprecation with a long runway. The deadline is firm. Merchants who have not migrated to Shopify Functions by the end of June will have their checkout customisations stop functioning on live orders.

What was Shopify Scripts?

Shopify Scripts was a Ruby-based customisation framework available exclusively to Shopify Plus merchants. It allowed merchants to write custom Ruby code that ran in Shopify's checkout to modify prices, shipping options, and payment methods in ways that standard Shopify settings could not achieve.

Scripts ran in three areas:

Line item scripts: custom discount logic applied to individual products or variants in the cart. Common use cases included volume discounts (buy 3, get 10% off), tiered pricing by customer tag or order total, and bundle-specific pricing not achievable with standard discount codes.

Shipping scripts: custom logic for displaying, hiding, or renaming shipping options at checkout. Common use cases included hiding standard rates for certain postcode ranges, offering dynamic free shipping thresholds based on cart contents, and renaming carrier names to branded service labels.

Payment scripts: custom logic for showing, hiding, or reordering payment methods at checkout. Common use cases included hiding certain payment methods for high-value orders, displaying methods conditionally based on customer country, and hiding net payment terms from retail customers.

Scripts were powerful but fragile. They required a developer to write and maintain Ruby code, they ran synchronously in the checkout (adding latency), and they could not be tested independently of a live or staging store. Shopify's retirement decision is partly performance-driven and partly architectural: Functions are a more robust replacement.

What is the retirement deadline?

Shopify has confirmed that Shopify Scripts will be retired at the end of June 2026. After this date:

Existing Scripts will stop executing in checkout
Any discounting, shipping, or payment customisation handled by Scripts will be removed
Merchants who have not migrated will see their checkout revert to base Shopify behaviour with no custom logic applied

If your Scripts have been running for years and no one on your team fully understands what they do, getting a developer to audit them before the deadline is urgent. Discovering what logic breaks on 1 July with live orders coming in is not a situation you want to be managing.

What are Shopify Functions?

Shopify Functions are the replacement for Scripts. They are a fundamentally different architecture that addresses the main weaknesses of Scripts.

Key differences:

Language: Functions are written in Rust, AssemblyScript, or any language that compiles to WebAssembly. Ruby is no longer used.
Deployment: Functions are packaged as Shopify app extensions and deployed through the Shopify CLI and Partners dashboard. They are versioned and testable like proper software.
Performance: Functions run as WebAssembly modules, executing faster and with less checkout latency than Ruby Scripts.
Testing: Functions include local development and testing tools that Scripts never had. You can validate logic before deploying to production.
Scope: Functions cover the same three customisation areas as Scripts, plus additional extensibility points not available in Scripts.

From a merchant perspective, the result is the same: custom logic in checkout. The difference is that Functions are more reliable, testable, and performant than Scripts.

Shopify Functions require Shopify Plus or, for some function types, a Shopify developer partner account. They are not available on standard Shopify plans.

How do you migrate common Scripts use cases?

Volume discounts and tiered pricing

Scripts approach: Ruby code calculating percentage discounts based on cart line quantity, customer tags, or order total thresholds.

Functions replacement: the Discount Function type. You create a custom discount app extension implementing the discount function API. The function receives cart data, applies your logic, and returns the discount to apply.

Shopify's native Discount API (part of Functions) handles standard discount configurations (buy X get Y, volume, order amount) without custom code for many use cases. Check whether your volume discount logic falls within native capabilities before building a custom Function.

Conditional free shipping

Scripts approach: Ruby code that hides or adds shipping options based on cart total, product tags, customer tags, or other cart attributes.

Functions replacement: the Shipping Discount Function type. You implement a function that receives shipping options and cart data, returning which options to show, hide, or modify. Free shipping above a threshold is achievable by returning a 100% discount on the relevant shipping option when the cart total condition is met.

For simpler conditional free shipping (orders over £X get free standard shipping), Shopify's native shipping rate rules may cover the use case without a custom Function. Audit your existing Script logic first.

Payment method hiding

Scripts approach: Ruby code removing certain payment methods from checkout display based on order value, customer country, product type, or customer tag.

Functions replacement: the Payment Customization Function type. It receives available payment methods and cart data, returning which methods to display or hide. Common use cases:

Hide buy-now-pay-later options above a certain order value
Hide cash-on-delivery for international orders
Show net payment terms only for customers tagged as trade accounts

Shipping method renaming and reordering

Scripts approach: Ruby code renaming carrier service names to branded alternatives at checkout.

Functions replacement: the Delivery Customization Function type. It allows renaming, reordering, and conditional display of shipping options.

What does a migration project actually involve?

A Scripts-to-Functions migration is a development project. It cannot be done through the Shopify admin. The steps are:

Audit existing Scripts: document every active Script, what it does, and what checkout behaviour depends on it. View active Scripts in your Shopify admin under Settings, then Apps and sales channels, then Script Editor.
Map each Script to a Function type: identify the equivalent Functions API for each Script (Discount, Shipping Customization, Delivery Customization, or Payment Customization).
Develop and test the Functions: Functions must be written in a WebAssembly-compatible language. A developer with Shopify Functions experience is significantly faster than one learning the platform during your project.
Deploy through a Shopify app: Functions must be deployed as extensions inside a Shopify app. For merchants, this is typically a custom private app in the Partners dashboard.
Test in a development store: test every use case covered by the original Script against the new Function before deploying to production.
Deploy to production and deactivate the Script: once verified, deploy the Function live and remove the old Script.

A straightforward migration of two or three Scripts with standard logic should take a developer 5 to 15 working days. Complex Scripts with edge cases, multi-currency handling, or unusual customer tag logic take longer. Get a scoped quote that includes development, testing, and deployment.

Where do you find a developer for the migration?

Your existing Shopify agency: if they built your Scripts, they should be able to migrate them. Ask specifically about their Shopify Functions experience before assuming capability.
Shopify Experts marketplace: Shopify's partner directory lists certified experts with Shopify Plus and Functions experience.
Freelance platforms: freelance Shopify developers with Functions experience are available on Upwork and similar platforms. Vet for proven Functions project history, not just general Shopify experience.

How urgent is this?

The deadline is the end of June 2026. Today is 21 May 2026. You have approximately six weeks.

A development project with scoping, development, testing, and deployment takes a minimum of two to four weeks for a developer with capacity available now. If you have more than two Scripts to migrate, you are at the point where you need to start today.

Merchants who start in mid-June will find it difficult to source available developers with Functions experience and will be racing against a hard deadline. Broken discount logic, unexpected shipping rates, and payment method problems in a live checkout are expensive problems to manage in real time.

Key actions to take now

Log into your Shopify admin today. Go to Settings, then Apps and sales channels, then Script Editor. List every active Script and document what it does in plain language.
Contact your existing Shopify agency today to scope a migration. Every week of delay narrows your available timeline.
For each Script, check whether the equivalent logic is available natively in Shopify settings (discount codes, shipping rate rules) before building a custom Function. Some cases may not require development.
Get a specific, scoped quote from a developer. A clear brief ("this Script applies a 10% discount when cart quantity exceeds 5 for products tagged 'wholesale'") will get a more accurate estimate than an open-ended request.
Plan for testing time. Budget at least two to three days for testing Functions against the original Script logic in a development store before deploying to production.
Set an internal hard deadline of 15 June 2026 for your Functions to be live and verified in production. This gives you two weeks of buffer before Shopify's deadline.

Frequently Asked Questions

What happens to my store if I miss the deadline?

After the end of June 2026, Shopify Scripts will stop executing. Any checkout behaviour relying on your Scripts will revert to default Shopify checkout behaviour. The impact depends on what your Scripts were doing: if they applied volume discounts, those discounts will stop applying. If they hid certain payment methods, all configured methods will become visible. If they managed conditional shipping, all configured shipping rates will show without conditions.

Do I need a Shopify app to use Functions?

Yes. Shopify Functions must be deployed as extensions inside a Shopify app. For individual merchants, this is typically a private app created in the Shopify Partners dashboard. Your developer handles this as part of the migration project. You do not need to publish the app to the Shopify App Store.

Can I use a third-party app instead of building a custom Function?

For some use cases, yes. Apps like Discount Ninja, Bold Discounts, and Automatic Discounts handle volume discounts and cart-level promotions using Functions under the hood. If your Scripts logic maps to what these apps offer, an app may be faster and cheaper than building a custom Function. For highly specific logic with unusual conditions or multi-currency rules, a custom Function is usually needed. Check the app's documentation against your Scripts logic before committing.

Are Shopify Functions available on standard Shopify plans?

Some Function types are available on all plans, but the discount and checkout customisation Functions used to replace Scripts are primarily a Shopify Plus feature. Standard Shopify plan merchants were not using Scripts (they were Plus-only), so this retirement does not affect them.

Shopify Scripts Is Being Retired: How to Migrate to Shopify Functions Before the Deadline