Shopify Scripts Are Gone: Replacing Quantity Limits and Checkout Rules With Functions

Shopify Scripts stopped running on June 30, 2026. Any scripts still published were deactivated, and nothing was migrated automatically. Discounts, shipping rules and payment rules move to their own Shopify Function APIs. Quantity limits and checkout rules move to Cart and Checkout Validation, and they behave differently. A script usually lowered the quantity in the cart without telling the customer. A validation Function blocks checkout and shows a message instead. It also runs on express checkouts, works on any plan when it comes from an App Store app, and can enforce rules that Scripts never could: store hours, daily order caps and per-customer limits across orders.

Last verified: September 28, 2026, against Shopify's help center, changelog and developer documentation. Sources are at the end.

Disclosure: OrderRules is a checkout validation app, one of the options below. Where Shopify's native tools do the job, we say so.

The timeline

Shopify's help center now reads: "Any Scripts that were still published on your store have been deactivated and no longer work." Checkout carried on without them. Whatever a script did simply stopped applying: a discount, a hidden shipping rate, or a quantity cap. If you didn't replace a quantity script, orders over your old limit can go through today.

What replaces each kind of script

Scripts came in three types: line item, shipping and payment. Each maps to a Function API or to a native feature.

To see what you had, open Apps → Script Editor and look for the customizations report. It covers payment, shipping and product discount scripts, with recommended apps and Function tutorials for each. It doesn't convert code. A quantity-capping script will appear as a product discount (line item) script, and the report won't necessarily point you to validation, so check those scripts by hand.

Quantity limits: the behaviour changed

This is the part most migration guides skip.

Scripts couldn't block checkout. The Script API had no way to reject a cart; the only "reject" was for discount codes. Stores that capped quantities used a workaround in a line item script: they forced the quantity down, or split the line and dropped the extra units. The customer reached checkout with fewer items than they chose, often with no explanation. These were community workarounds, not documented features.

Functions can't change quantities. Cart Transform can expand, merge or re-present lines, but it can't reduce them. The Function-era tool for limits is Cart and Checkout Validation. It checks the cart and, when a rule is broken, blocks checkout and shows a message, for example "You can buy up to 2 of this item."

What that means when you migrate:

• Write the message. A customer who hits a limit now sees your wording at checkout. Say what to change: "Remove 1 to continue", not "Error".
• Show the limit earlier. Put the limit on the product page and in the cart, so the checkout message is rarely a surprise. Validation apps usually ship a theme block for this. OrderRules shows limits on product pages and can adjust quantity inputs to valid multiples.
• Express checkouts are covered. Shopify states that validation includes express checkouts: Shop Pay, PayPal, Google Pay and Apple Pay. Theme-only quantity limits don't hold there, because buy-now buttons skip the cart.

Rules Scripts could never enforce

Scripts ran in a sandbox. They had no web requests, no database, and, in Shopify's words, they couldn't "involve random or time-based calculations". They saw the current cart, plus a customer's tags, order count and total spent. So three common rules were never possible in Scripts:

If you gave up on one of these because Scripts couldn't do it, it's worth another look.

Plans: Plus is no longer required

Scripts were Shopify Plus only. Functions are different:

• Public App Store apps with Functions work on any plan, including Basic.
• Custom apps with Functions still need Plus.
• Checkout Blocks order value limits and B2B quantity rules are on all plans since April 2026.

So a store that moved off Plus, or never had it, can enforce checkout rules that once needed Plus.

Where validation doesn't run

Validation Functions cover the online store checkout, express checkouts, the cart, B2B checkouts and draft orders. Shopify lists these as not supported:

• POS
• Subscription renewals (recurring orders)
• Order edits, in the admin or at checkout
• Orders created through the Create Order API
• Pre-order and try-before-you-buy purchase options

If a rule has to hold in one of these places, plan something else, such as staff procedures at POS. In OrderRules, POS orders and subscription renewals still count toward limits even though they aren't blocked. The full list is on our compatibility and known limitations page.

A migration checklist for quantity and checkout rules

1. List your scripts. Open the customizations report, and your Script Editor code if you kept a copy. Note every line item script that touched quantity.
2. Write each rule in one sentence. For example, "Max 2 of this hoodie per order", "Wholesale buyers order in 12s", or "No orders over $2,000 without approval". It's easier to choose a replacement for a sentence than for Ruby code.
3. Take the native options first.
   • Order value limits → Checkout Blocks.
   • B2B minimums and multiples → B2B catalog quantity rules.
   • One huge cart of a stocked item → the add-to-cart limit (Settings → Checkout; inventory-tracked products only).
4. Choose an app for the rest. Minimums and multiples for regular shoppers, caps per day or week, per-customer limits across orders, and store hours all need a validation app.
5. Rewrite messages as instructions, and show limits on product pages.
6. Test every path. Test normal checkout, Shop Pay, a buy-now button and a draft order. Then write down what won't be checked: POS, subscription renewals and order edits.

For a rule-by-rule view of what Shopify now does natively, see Shopify's native order limits vs apps.

Where OrderRules fits

OrderRules is a public App Store app built on Shopify's checkout validation, so it works on any plan. It covers the quantity and checkout rules that Scripts handled badly or couldn't handle:

• Minimum order quantity and step quantity per product or variant, for every shopper. See the minimum order quantity guide.
• Daily, weekly and monthly caps for the store, a product or a collection.
• Per-customer limits across orders by orders, units, spend or weight. Customers must log in; see per-customer purchase limits.
• Store hours and holiday closures that close checkout.

It doesn't set order value minimums (use Checkout Blocks). It has no per-order maximum for a single product; for that, use Shopify's add-to-cart limit or a per-customer daily limit. For how validation works under the hood, see Shopify checkout validation explained.

Sources

• Shopify changelog: Scripts can no longer be edited or published (Mar 12, 2026) · Customizations report (Feb 4, 2025)
• Shopify.dev changelog: Shopify Scripts will be deprecated on June 30, 2026
• Shopify Help Center: Script Editor · Limitations · Transitioning to Functions
• Shopify.dev: Cart and Checkout Validation Function API · Cart Transform · Shopify Functions availability
• Shopify changelog: Checkout Blocks order value limits on all plans (Apr 13, 2026) · B2B features on non-Plus plans (Apr 2, 2026)
• Shopify Community: Shopify Scripts deprecation announcement (Feb 2023)