Last updated: August 2026

If your store ran on Shopify Plus and used a custom Script for checkout logic, it stopped working weeks ago. Shopify Scripts was officially deprecated on June 30, 2026 — every published Script was deactivated that day, and editing or publishing new ones had already been blocked since April 15. There's no opt-out, no extension, and no rollback. If nobody migrated that logic before the deadline, your store has been running on plain default behavior since July, and it may not be obvious from the storefront that anything changed at all.

That's the part that catches merchants off guard. A broken Script doesn't throw an error a shopper can see — it just stops applying. A tiered discount silently stops discounting. A hidden payment method silently reappears. If you're only now noticing something in your cart or checkout logic isn't working the way it used to, this is very likely why.

What Shopify Scripts actually did

Scripts were a Shopify Plus-only feature: merchants (or, more often, a developer they hired) wrote Ruby code that ran at checkout to customize one of three things:

  • Line item scripts — adjusted the price of products already in the cart, applied conditional discounts, or hid and reordered cart lines
  • Shipping line scripts — hid, renamed, reordered, or filtered shipping rates based on cart contents or destination
  • Payment gateway scripts — hid, renamed, or reordered payment methods based on cart total, customer tags, or other conditions

One thing Scripts could never do, even at their most powerful: add a brand-new product to the cart. A line item script could change the price of a product that was already sitting in the cart — including pricing it down to $0 — but it had no way to put a product there in the first place. That limitation matters later in this article.

What replaces Scripts: Shopify Functions

Shopify's own migration guidance maps each Script category to a Functions equivalent — Shopify even built a Scripts customizations report into the admin that lists every Script your store had active before the deadline and links each one to a matching Function or app:

Legacy Script type Shopify Functions replacement
Line item / discount scripts Discount functions
Shipping line scripts Delivery customization functions
Payment gateway scripts Payment customization functions

Functions are Shopify's newer extension model: instead of editing Ruby code inside a checkout-adjacent editor, the logic runs as a compiled module — packaged inside an app rather than pasted into a text box. That app can be one of two things:

  1. A public app from the Shopify App Store that already has the Function built in — you install it, configure it through a normal settings screen, no code involved.
  2. A private, custom-built app — a developer writes the Function specifically for your store, the same way a developer used to write your Script.

The plan requirement carries over almost exactly from Scripts: building a custom, private Function app still requires Shopify Plus, per Shopify's Functions documentation. If your Script was genuinely bespoke — a discount formula unique to your business, a payment rule tied to a specific customer segment only you have — replacing it means the same thing replacing your Script did in the first place: a developer, on Plus. Functions changed the underlying framework, not the skill and plan requirement for one-off custom logic.

Where the picture actually improves for most merchants is everything that wasn't bespoke. Most Script use cases fall into common, well-understood patterns — buy-X-get-Y pricing, hiding a shipping rate for certain products, hiding cash-on-delivery above a certain order value — and Shopify's own recommendation for those is the App Store, not a developer. That's the "no code needed" side of this migration: if a packaged app already does the job, you don't rebuild anything, you just install it.

The gap neither Scripts nor Functions ever closed

Here's the detail that trips merchants up most: nothing in the Scripts-to-Functions migration adds the ability to put a new product into a customer's cart based on a rule. Discount functions can change a price. Delivery and payment customization functions can hide, rename, and reorder existing options. Even Shopify's newest addition, Cart Transform functions, only operate on line items already sitting in the cart — merging them, splitting a bundle SKU into its components, or updating price and presentation. None of these can reach into your catalog and add an unrelated product because a cart crossed $75 or a customer is tagged VIP.

That was never a Scripts job, and it isn't a Functions job either. It's always been a different mechanism: an app that runs through Shopify's Cart API — the same interface every storefront cart uses, available on every plan, with no framework migration to worry about because it was never built on Scripts or Functions in the first place. AutoCart works this way. It's not a Function you install and configure through the checkout extensibility framework; it's a rule engine that watches the cart and adds (or removes) a real product line item when your conditions are met.

If you were using a Script as a workaround to fake a free-gift offer — for example, requiring the customer to manually add a "gift" product, then having the Script zero out its price once the qualifying purchase was in the cart — that workaround relied on the customer doing the one thing your Script couldn't: getting the product into the cart. Losing the Script doesn't just remove some logic, it removes the whole workaround. Rebuilding it as a Discount function would hit the exact same wall, because pricing something to $0 and adding it to the cart have always been two separate problems. A rule-based app that auto-adds the product directly — no manual step, no discount workaround — was always the more direct way to run a gift-with-purchase, BOGO, or bundle-add offer. The Scripts deadline is a good forcing function to switch to it. See our complete guide to gift-with-purchase setup methods for how the auto-add approach compares to the discount-code workaround.

Migration checklist by Script type

Match what your Script did to the right next step:

  1. Conditional discount or price adjustment on items already in the cart. You need a Discount function. Check the App Store first for a packaged app covering your exact use case (tiered pricing, BOGO-style percentage-off) — most common discount logic doesn't require custom development. Genuinely unique pricing formulas still need a developer and Shopify Plus.
  2. Hiding, renaming, or reordering shipping rates. You need a Delivery customization function. This is a common enough job that packaged apps exist for it — our sister app HideShip hides, sorts, and renames shipping rates through this exact function type, no code and no Plus requirement to use it.
  3. Hiding or reordering payment methods. You need a Payment customization function — same pattern: check for a packaged app before commissioning custom development.
  4. Auto-adding a free gift, bundle component, or BOGO item to the cart based on a rule. This was never something your Script did directly, and it isn't something a Function does directly either. A rule-based cart app running on the Cart API — like AutoCart — is the tool built for this specific job. Set a condition (cart value, a specific product, a customer tag, a collection, or cart quantity) and the action (add this product), and it runs automatically on any plan.

Common mistakes during the migration

  • Assuming a silent Script means a silent problem. A deactivated Script doesn't produce an error message anywhere a merchant would normally look. If a discount, shipping rule, or payment restriction that used to work no longer applies, check the Scripts customizations report in your admin before assuming the storefront is fine.
  • Rebuilding a discount-based "gift" workaround as a Function instead of switching mechanisms. If your Script's job was ultimately to get a product into the cart, porting the same pricing-trick logic to a Discount function just recreates the same manual-add friction for customers. A cart-auto-add app solves the actual problem instead of the workaround.
  • Assuming every replacement needs Shopify Plus. Building a custom, private Function does. Installing a packaged app that already uses Functions — or a Cart API app like AutoCart — doesn't. Check what's already built before budgeting for development work.
  • Waiting to check what Scripts your store actually had active. The Scripts customizations report only reflects what was published before June 30, 2026. If you're not sure what your store relied on, that report — not guesswork — is the place to start.

Shopify Scripts to Functions migration: frequently asked questions

What happened to Shopify Scripts? Shopify Scripts was deprecated on June 30, 2026. Editing or publishing new Scripts stopped working on April 15, 2026, and every previously published Script was deactivated on the June 30 deadline. There's no way to reactivate them.

Do I need a developer to replace my Shopify Script? Only if what your Script did was genuinely custom. Most common use cases — standard discount logic, hiding a shipping rate, hiding a payment method — already have packaged apps built on Shopify Functions that you can install and configure without code. Bespoke, store-specific logic still needs a developer.

Do I need Shopify Plus to use Shopify Functions? Only to build or run a custom, private Function app. Public apps from the Shopify App Store that use Functions internally work on any plan, and the Cart API — which apps like AutoCart use for auto-adding products — has never been plan-gated.

Does AutoCart replace my Shopify Script? Not directly — AutoCart was never built on Scripts or Functions, so there's nothing to migrate. If your Script's purpose was to get a product into the cart automatically (a free gift, a BOGO item, a bundle component), AutoCart is the tool built for that job, whether or not you ever had a Script for it. If your Script adjusted prices, shipping rates, or payment methods, you'll still need a Discount, Delivery customization, or Payment customization function for that piece.

Is it too late to migrate if I missed the June 30 deadline? No — Scripts simply won't come back regardless of when you act. Check your store's Scripts customizations report in the Shopify admin to see exactly what was active, then work through each item against the checklist above.

Move the cart-level logic to a rule engine, not a workaround

The Scripts deadline forces a real decision for every piece of logic it used to run — but not all of that logic needs the same answer. Discounts, shipping rates, and payment methods route to Shopify Functions, with a developer and Plus only required for genuinely custom builds. Getting a product into the cart automatically was never part of that framework at all, and it still isn't — it's a Cart API job, which is what AutoCart was built for from the start. No migration, no Plus requirement, no waiting on development time.

See our guide to how Shopify cart rules work for the mechanics, or how AutoCart and HideShip together cover checkout control without Shopify Plus.

Try AutoCart free on your Shopify store: apps.shopify.com/autocart-auto-add-to-cart