Blog · July 10, 2026
Describe the job, watch the AI build it, rehearse it, deploy it.
Free plan · no card · 🇪🇺 EU data residency
Shopify turned off Scripts on June 30, 2026. Checkout logic has an official successor in Shopify Functions; the repricing, tagging, and feed scripts many stores ran around it do not. Here is where each kind of script goes now.
With Shopify Scripts deprecated, the easiest new home for your scheduled pricing, tagging, and feed jobs is the Collaudo app: it runs them as real Python or TypeScript you dry-run against your live catalog, and nothing writes until you approve the mutation report. Checkout and discount logic goes to Shopify Functions instead; Collaudo covers the recurring store-side work, not checkout.
Shopify turned Scripts off on June 30, 2026, and if your scripts ran checkout logic (line-item discounts, shipping rules, payment customization), the answer is Shopify Functions, the official successor: migrate that logic there, and you are done. This guide is for everything else your scripts did.
Scripts was narrower than its reputation. It was Ruby in the Script Editor app, available on Shopify Plus, and it ran at checkout. For years, though, it was the one sanctioned place to run your own code inside Shopify, and around it grew a habit: scripting the store itself (nightly repricing, seasonal retagging, Google Merchant feeds, inventory pulled from a supplier's API on a timer). Those jobs lived in one-off scripts and cron jobs on whatever server was handy, and that half of the habit has no official successor.
Every script falls into one of two piles, and each pile has a different fate. Pile one is checkout-time logic: the tiered discounts, shipping rules, and payment reordering that ran while a shopper paid. Pile two is store-side work: code that edits the store itself (repricing a catalog, retagging products for a season, generating a Merchant Center feed, syncing stock from a warehouse system, maintaining per-customer B2B price lists).
Shopify deprecated Scripts with a paved road for pile one only. Functions exists, the migration is documented, and the deadline has passed. Pile two was never what Scripts was for, which is why nobody built its successor. Those jobs accumulated informally: a developer wrote a script in an afternoon, someone reran it by hand each season, eventually a cron job ran it nightly. Deprecation day changed nothing for them, and that is the uncomfortable part: they were already unowned.
Shopify Functions covers checkout logic, and only checkout logic. It is the official alternative to Shopify Scripts for what Scripts was built to do: discounts, shipping customization, payment customization. If your Ruby computed a volume discount or hid a payment method for certain carts, port that logic to Functions and retire the script with a clear conscience.
The shape of what Functions cannot do matters more here. Functions run inside checkout events: a cart exists, a buyer is paying, and the function customizes that transaction. There is no scheduler. A Function cannot wake at midnight, walk your catalog, and reprice it. It cannot call a supplier's API on a timer or push a feed to Merchant Center. If a job's trigger is a clock rather than a checkout, Functions is not the destination.
Shopify Flow is the right home for event rules, and it is free. It ships with your plan, lives inside the admin, and handles rules shaped like "when a product is created, if the vendor matches, add a tag" without code. Under about 1,000 products with simple trigger-condition-action logic, Flow covers most of what stores used to script, and reaching for anything heavier wastes money.
Scripted jobs outgrow Flow along four lines. Flow reacts to events one product or order at a time; it is not built for catalog-wide scheduled computation. It compares and routes; it does not do arithmetic across fields, like deriving a price from cost, margin band, and a rounding rule. It works with its own connectors; a supplier API with custom auth and pagination sits out of reach. And its unit of thought is the trigger, so "every night, recompute all sale tags from scratch" has no natural shape in it. If your old script did any of those, Flow is not the successor either.
You can host a script and call the Admin API on a schedule. That is the direct descendant of the scripting habit: full control, any language, any trigger. Put the code on a server or a serverless function, schedule it, authenticate with a custom app token, and use the GraphQL Admin API. GraphQL is the current direction, and REST is legacy.
Then count what you now own:
None of that is exotic engineering. If a developer owns the job (by name, with alerts wired to a channel someone reads), this route works, and it is the cheapest at small scale. The failure mode is ownership decay. The script that worked in April fails silently in October: an API version sunsets, a token expires, one product grows a null field the code never met. Nobody notices until the feed goes stale or a wrong price sits live for a week.
Every route ends the same way: a scheduled write, unwatched. This is where store-side jobs differ from checkout logic. A buggy Function mangles one checkout and a customer tells you within the hour. A buggy nightly job retags or reprices the whole catalog overnight and greets you at breakfast.
Editing 10,000 products isn't the problem — doing it again every week without mistakes is. The first run of any script gets watched; the fortieth does not. So before choosing a destination for pile two, ask what each route gives you at the moment of the write:
The DIY route can build all of this, at the price of building it. Flow offers some of it within its scope. Functions never needed it, because checkout logic does not bulk-write. For scheduled store-side jobs, a rehearsal before the write is what separates an automation from a scheduled incident.
Shopify Scripts has no single replacement; it has three, split by job. Checkout logic (discounts, shipping, payment customization) moves to Shopify Functions, the official successor. Event rules shaped like "when X happens, if Y, do Z" belong in Shopify Flow, which is free and native. The third pile (scheduled, catalog-wide jobs like repricing, tagging, and feed generation) was never officially Scripts' job, but Scripts normalized running code against a store, and those jobs have no sanctioned successor. They either move to a script you host and maintain against the Admin API, or to an automation platform like Collaudo, where the job runs as real Python or TypeScript on a schedule and every run is rehearsed against the live catalog before anything is written. Shopify does not have a built-in undo for bulk edits, so the rehearsal is the safety layer.
Collaudo runs pile two as real code, with a rehearsal before every write. You describe the job in plain English (reprice from this cost sheet nightly, round to charm prices, skip anything on clearance) and Collaudo writes real Python or TypeScript you can read, edit, and keep. Of every route above, this is the closest to your old scripts: code you own, without the server.
Before a job goes live, it dry-runs against your actual catalog. The code runs for real, reads your products, computes every change, and holds every write. You get a mutation report (what would change, item by item, and what was deliberately skipped) and nothing touches the store until you approve it. Real-code workflows with a dry run before every change. Once approved, the job runs on a schedule, on an event, or on demand, on AWS infrastructure in eu-central-1 (Frankfurt), with EU data residency, a full audit trail, and versions you can restore. Dry runs and runs are never billed per execution; plans are flat monthly, with a per-tier allowance of AI generations.
Checkout logic goes to Functions. A simple event rule on a small catalog goes to Flow, and Flow is free. A cron job with a developer who owns it is a fine home too. Collaudo is for the pile in the middle: the scheduled, catalog-wide, store-writing jobs that used to run with nobody watching. See how it works, start from a pricing template, or check plans.
Shopify Functions replaced Shopify Scripts for checkout logic: discounts, shipping, and payment customization. There is no official successor for the other jobs stores ran as scripts, such as scheduled repricing, tagging, or feed generation. For those, the realistic options are Shopify Flow for simple event rules, a self-hosted script against the Admin API, or an automation platform that runs code on a schedule.
No. Shopify deprecated Script Editor and turned it off on June 30, 2026, and existing scripts stopped running at checkout. If your scripts handled discounts, shipping, or payment customization, migrate that logic to Shopify Functions. If they handled store-side work like repricing or tagging, that work needs a new home, because Functions does not cover it.
No. Functions run inside checkout events: a shopper's cart triggers them, and they customize discounts, shipping, or payment options for that checkout. They have no scheduler, cannot run a nightly pass over your catalog, and cannot call external systems on a timer. Scheduled or bulk work needs Flow for simple event rules, a self-hosted script, or an automation platform built for recurring jobs.
Two routes. Host your own script (a server or serverless function that calls the GraphQL Admin API on a cron schedule) and own rate limits, retries, pagination, failure recovery, and logging yourself. Or use an automation platform such as Collaudo, where you describe the job, review the generated code, dry-run it against your real catalog, and then schedule it, with logs and approvals handled for you.