The Shopify Scripts sunset.
What merchants need to do
before June 2026.

A merchant I know found out about the Scripts deadline the hard way. A customer emailed saying their bulk discount wasn't applying at checkout. No error message. No warning in the Shopify admin. Just a discount that silently stopped working.

They spent an hour troubleshooting before realizing: their Line Item Script — the Ruby code that had been powering a tiered discount for three years — was gone. Not broken. Gone. Because June 30 had come and Shopify had pulled the plug.

That story isn't hypothetical. It's the exact scenario thousands of Shopify Plus merchants are heading toward right now. The difference between that merchant and you is that you're reading this today, with five weeks still on the clock.

Here's what Shopify Scripts actually are, why Shopify is retiring them, and the step-by-step process to migrate before your checkout starts misbehaving.

Two deadlines.
One already passed.

Shopify announced the Scripts deprecation in 2024, with a June 2025 original deadline that was pushed back twice. The final timeline has two distinct dates that matter:

FIG. 01 — DEPRECATION SCHEDULE SCALE 1:1 · REV. 2026.05

The Shopify Scripts deprecation timeline. The April 15 editing cutoff has already passed — Scripts stop executing entirely on June 30, 2026.

April 15, 2026 (already passed): Shopify disabled the ability to create or edit Scripts in the Script Editor. Any Script that was live on April 14 is still running — but frozen. You can't fix a bug, adjust a discount threshold, or tweak a shipping rule. What's there is what's there.

June 30, 2026 (five weeks away): All Scripts stop executing. Completely. Discounts won't apply, shipping rules won't fire, payment gateway logic won't run. Customers will hit your checkout without any of the customization you've built over the years.

The Scripts that are live today will keep running until June 30 — but if anything breaks between now and then, you have no way to fix it.

What Shopify Scripts
actually do.

Scripts are small pieces of Ruby code that run in the background during checkout. They were introduced as a Shopify Plus-only feature and gave merchants a way to build custom checkout logic that wasn't possible through Shopify's standard discount and shipping settings.

There are three types. It's worth knowing which ones you're using because the migration path differs by type.

If you're not sure which types you have, jump to the audit section below before reading further. Knowing what you're working with changes everything about how you approach this.

What's replacing Scripts
(and why it's actually better).

Shopify Functions are the new infrastructure for checkout customization. They've been in development since 2022 and are now mature enough that Shopify is comfortable making the hard cut.

The key difference for merchants: Functions run faster, work on all Shopify plans (not just Plus), and are available through apps in the Shopify App Store — meaning most merchants won't need a developer at all.

The performance gap is more meaningful than it sounds. Scripts ran Ruby on Shopify's servers, with cold start overhead and variable latency that got worse under load — Black Friday was notoriously rough for stores with complex Scripts. Functions compile to WebAssembly and run in under 5ms, every time. Shopify enforces that as a hard execution budget. There's no cold start, no CPU throttling during a flash sale, no latency spike when thousands of carts hit checkout simultaneously. If your Scripts were occasionally causing checkout slowdowns, this is the fix.

The reach is also different. Scripts were locked to three surfaces: line items, shipping, and payments. Functions go further — cart and checkout validation (block checkout with a custom error when business rules aren't met), order routing to control which fulfillment location ships what, and a growing list of extension points Shopify has been shipping quarterly since 2022. A merchant running complex wholesale rules or multi-location fulfillment will find more to work with in Functions than Scripts ever offered.

On the developer side: Functions are written in JavaScript, TypeScript, or Rust — not Ruby. Shopify CLI handles compilation via its own JavaScript-to-WebAssembly toolchain (Javy), so the development experience is closer to what most Shopify developers already know. For most merchants, though, none of that matters directly. No-code apps built on Functions handle the common patterns — tiered discounts, BOGO, free shipping thresholds, payment method visibility — without anyone writing a line of code.

Step one: find out what
Scripts you're actually running.

Before you do anything else, you need to know what's live in your store. A surprising number of merchants discover they have Scripts they forgot about — set up years ago by a developer, quietly running in the background.

The Customizations Report is worth spending 10 minutes in. Shopify has done the work of mapping your specific Scripts to the apps and Functions APIs that can replace them. It's not a generic list — it's tailored to what's actually running in your store.

What you're looking for in the audit: which Script types are active (Line Item, Shipping, Payment), what each one does, and whether it's business-critical or vestigial. Some merchants find Scripts that haven't been relevant in two years. Others find their entire discount strategy sitting in one Script file.

Your three
migration paths.

Once you know what Scripts you're running, the migration decision is actually pretty simple. There are three ways to go, and which one fits depends on what you're replacing and how complex it is.

FIG. 03 — DECISION FLOW SCALE 1:1 · REV. 2026.05

A simple framework for deciding your migration approach based on what Scripts you're running and the resources available.

Path 01 / Install a no-code app (most merchants)

For the most common Script use cases — tiered discounts, BOGO, free shipping thresholds, hiding or reordering payment methods — there's a no-code app that handles it. These apps are built on Shopify Functions under the hood, so they're Shopify-approved replacements, not workarounds.

Your Scripts Customizations Report will surface apps specific to what's running in your store, so use that as your primary source. The apps above are a starting point, not an exhaustive list.

Path 02 / Custom Function development (complex or proprietary logic)

Some Scripts were built to handle genuinely custom logic — deep integrations with third-party systems, unusual pricing structures, logic that's tightly coupled to your business rules. A no-code app won't recreate that.

For those cases, a Shopify developer can build custom Functions using Shopify's Functions API. The developer experience is different from Scripts (WebAssembly instead of Ruby), so make sure whoever you hire is familiar with the current Functions platform specifically — not just Shopify development generally.

If you need to hire for this, don't wait. Lead times for Shopify developers familiar with Functions are running 2 to 4 weeks right now, and June 30 isn't moving.

Path 03 / Hybrid approach (most realistic for complex stores)

Many stores with 3 or more active Scripts will find that some can go to no-code apps, one or two need custom development, and a couple are actually unused and can be retired. Map your Scripts against all three outcomes before you commit to any one path.

The five-week
action plan.

You have roughly 38 days. Here's how to use them without scrambling at the end of June.

---

The bigger
picture.

Scripts were always a stopgap. Ruby code running in a sandboxed environment on Shopify's servers, doing things the platform was never built to handle at the volume merchants were pushing it to. The fact that it worked as well as it did, for as long as it did, is genuinely impressive. But Shopify was always going to replace it with something native to how checkout actually runs at scale.

Functions are that replacement — not a better workaround, actual infrastructure. If you migrate well, your checkout gets faster, your discount and shipping logic becomes easier to modify without calling in a developer, and you're building on a platform Shopify is actively investing in. If you don't migrate, your checkout stops working on July 1. That's the whole equation.

One thing worth noting for anyone who's been in the Shopify ecosystem long enough: the extension points for Functions are still growing. Cart and checkout validation, order routing, fulfillment location rules — none of that existed with Scripts. Merchants who make this transition now are moving onto a platform that will keep getting more capable, not less.