Shopify Scripts are being deprecated, and from June 30, 2026, existing, and from June 30, 2026, existing Scripts will stop working completely.
For Shopify Plus stores, this can affect custom discount logic, shipping rules, payment method rules, wholesale pricing, bundle logic, and other checkout customizations.
It looks like the main migration path is Shopify Functions, but depending looks like the main migration path is Shopify Functions, but depending on the use case, some stores may need a public on the use case, some stores may need a public app or custom app logic instead.
Yeah, that Scripts sunset is forcing a lot of Plus merchants to rethink their checkout stack right now. Shopify Functions are the long-term path, but they’re still pretty limited for complex discount and pricing logic, and they require dev resources to maintain.
For the stuff you mentioned (custom discounts, shipping rules, payment gating, wholesale pricing, bundle logic), a lot of shops we work with on Plus stores have migrated to Checkout Boost instead. It handles discount stacking, tiered/BOGO logic, customer-tag-based pricing, payment-method rules, and B2B net-terms stuff all through the UI- no Functions or custom code needed. It’s a paid app on the App Store, but it’s usually faster to implement than rebuilding everything in Functions.
Functions are still worth evaluating for really niche logic that doesn’t fit the standard discount/shipping/payment patterns. But if your Scripts are mostly doing the checkout customizations you listed, you might find Checkout Boost covers most of the migration without the dev overhead.
Okay, I did a lot of work on this so I believe I can offer some helpful advice. I’d approach this by splitting your existing Scripts into buckets first.
Not every Script needs the same replacement path. Some can be replaced by
a public app, some need a custom Shopify Function, and some might be worth
removing if the business no longer relies on that rule.
Roughly:
Discount logic → usually Shopify Functions or a discount app built on Functions
Shipping rules → delivery/custom shipping Functions or a shipping rules app
Wholesale/B2B pricing → depends heavily on how custom your current setup is
Bundle logic → often needs a proper bundles app or custom Function logic
The big thing I would avoid is treating this like a 1:1 “convert my Ruby
Script into Functions” task. Functions are a different model, so it is better
to write down the actual business rule first, then decide whether an app or
custom Function is the cleanest replacement.
For custom discount rules specifically, this is also where apps can make more
sense than custom development. For example, if the Script was doing something
like “this customer can use this discount 3 times” or “VIP customers get 2 uses
every 30 days,” Shopify’s native discount settings do not really cover that
middle ground well.
Full disclosure: I built an app called Discount Spark that solves this
specific discount-use-limit problem. It lets merchants create Shopify discount
codes with custom per-customer usage limits, like 3 uses per customer, or 1 use
every 30 days. It is not a replacement for every Script use case — it will not
replace shipping/payment/wholesale/bundle logic — but if part of your Script
setup is controlled repeat-use discounts, it can save you from rebuilding that
logic from scratch.
So my general answer would be: inventory the Scripts, classify them by business
rule, use Shopify Functions where the logic is truly custom, and use focused
Function-based apps where the rule is already covered well.
Migrate your Shopify Scripts to Shopify Functions ( for discount, shipping, and payment rules) by building or installing the public app before 30 June 2026.
The good news is most of the popular promotion apps have already moved to Shopify Functions, so if you were using Scripts mainly for discount logic (tiered pricing, BOGO, conditional free gifts, etc.), you’re probably covered by an app without needing to write custom Functions yourself.
BOGOS, Discount Ninja, and Kite all run on Shopify Functions now. If your Scripts were handling things like “spend $100 get a free gift” or “buy 2 get 15% off,” those are basically plug-and-play replacements. BOGOS in particular covers the free gift, BOGO, volume discount, and bundle logic that a lot of Plus stores were using Scripts for.
Where it gets trickier is if your Scripts were doing something more custom, like modifying shipping rates based on product combinations or applying customer-tag-based wholesale pricing with specific rounding rules. For those, you’re looking at either building a custom Shopify Function (which needs a developer and a custom app to host it) or finding a niche app that handles your exact use case.
For B2B logic, I’d avoid replacing Scripts with another fragile workaround if the rule is business-critical.
Things like order limits, buyer eligibility, PO validation, or credit-limit enforcement really need to happen server-side at checkout, not only in theme code or manual review.
Shopify Functions / Cart and Checkout Validation are the cleaner direction for that kind of rule.
For example, a B2B credit-limit check should block the checkout before the order is created, not tag the order afterward and hope someone catches it.
Salepark’s bucket approach above is the right frame — the migration path really depends on what each Script did. One practical thing I’d add: keep your old Ruby files even though Scripts are dead now. That file is still the exact spec of your business logic, and whoever rebuilds your rules will need it as the reference.
Full disclosure, I’m the developer of one of the replacement apps — Scriptly. I built it for the no-dev path: common Script patterns (tiered/quantity discounts, spend thresholds, tag-based VIP pricing, shipping and payment rules) as no-code rules on Shopify Functions, with an AI importer that reads your old Ruby script and recreates the rules from it, and a simulator to test everything before it goes live. Honest scope: if your Scripts did truly custom things — external API calls, credit limits, PO validation like Termguard describes — that still needs a custom Function built by a developer; no rule-builder honestly covers that.
Either way, don’t sit on this: Scripts that silently stopped on June 30 usually mean full-price checkouts, and customers rarely report it — they just leave.
As most have said, Shopify Functions is the primary solution. In the case of hard coded discounts needing replacement from Scripts, Regios has been an app some of our users have moved to. (We’re not affiliated, just trying to help with another option).
If any of your Scripts were doing order limits or minimums, that part moves to a Cart and Checkout Validation function, which is a different thing from the discount functions most of this thread is about. Easy to pick the wrong one. Minimums, maximums and multiples all carry over fine, and the rule gets checked at checkout so express wallets can’t skip it. What doesn’t carry over is anything that needed the buyer’s order history, because validation only sees the current cart. I build an app for the limits side, Mastiff, free for one rule. For the discount logic the apps others named here are a better fit than mine.
If your scripts went dark on June 30 and you’re still working out what replaces what, start with the Shopify Scripts customizations report in your admin. It lists everything you had running and points each one at its Functions or app equivalent, so you’re not reverse-engineering the migration by hand.
Heads up on the timeline since it keeps tripping people up: editing was cut off back on April 15, everything stopped executing on June 30, and the Script Editor was only read-only through July 30. So if you were planning to open your old Ruby as a reference, that window’s closed now and the customizations report is basically your record of what those scripts did. Worth pulling it before you rebuild anything.
The bucket that catches people out: discounts, shipping and payment rules move to the discount, delivery and payment Functions, but things like order minimums or credit-limit checks are a Cart and Checkout Validation function instead. Different API, and it only sees the current cart, not the customer’s order history, so anything that keyed off past orders won’t port straight across.
Full disclosure, I work on one of the discount apps mentioned in here, Flowly. The thing that sets it apart from most of the options above is the AI mode: you describe the discount you want in plain English and it builds the actual rule for you, real products pulled in and all, then you adjust it visually. Grain of salt from me obviously, but the other options named here are solid too. Flowly: Discount Functions - No-code discount rule builder for Functions set up in minutes. | Shopify App Store
Worth flagging one thing, because these two keep getting mixed up and the deadline is 12 days away.
Shopify Scripts and the 26 August change are separate migrations. Scripts were Ruby, they only ever handled discount, shipping and payment logic, and they stopped executing on 30 June. Tracking never lived there.
What happens on 26 August is different: non-Plus stores lose the legacy Thank You and Order Status pages, and the Additional Scripts field goes with them. That’s where conversion tracking lived — Google Ads tags, Meta pixels, GTM containers, affiliate scripts. Removed, not migrated.
So if you’ve sorted your Scripts replacement, that doesn’t mean your tracking is covered. Different field, different deadline, different fix — tracking moves to Web Pixels under Settings → Customer events.
I feel like it’d be useful for me to reply here as I’m involved with shopify functions often. @Salepark 's bucket approach is the right way to go about this, write down the actual business rule first and then pick the replacement, don’t try to port the ruby 1:1
Please also remember custom developed apps are only an option if you’re on Shopify Plus when creating functions, it is not possible on other plans, those require an app from the shopify app store. You’re on Plus so both paths are open to you, but a custom function for every single rule adds up quickly in dev time and maintenance, especially once the person who wrote it leaves
For the discount, shipping, payment and bundle buckets you listed, the app SMART Functions Creator covers all of them in one place - discount functions (product, order, shipping, BXGY, volume, fixed bundle price), payment & delivery customizations, cart & checkout validation and cart transforms. Conditions go pretty deep as well - customer tags, metafields, address, line item properties and many more with AND/OR groups, so most Scripts logic rebuilds as a rule without touching code. 1 automatic discount can also hold up to 100 discounts, so the 25 limit isn’t a problem for bigger campaigns
There’s no rule cap from the app, only Shopify’s own limits apply. Honest scope as others mentioned - anything that called an external api or needed the customer’s detailed (specific products ordered for example) order history still needs a custom function, no rule builder covers that
