Shopify Scripts stopped running June 30, 2026. Compare Functions vs Scripts, map each Script type to the right Function API, and decide when a public app beats a custom Function build.
Shopify Scripts were deprecated June 30, 2026 and no longer execute. Shopify Functions (WebAssembly modules shipped in apps) run during the buyer journey for discounts, delivery customization, payment customization, cart transforms, and validations. Use the Scripts customizations report to inventory what existed. Public App Store apps with Functions work on paid plans; custom Function apps require Plus. Flow cannot replace checkout-time price logic.
Shopify Scripts were deprecated on June 30, 2026. They no longer execute at checkout. Script Editor is retired as a live customization surface. What remains in admin is the Scripts customizations report—a historical inventory of what your store ran before deprecation, with links to migration guidance.
Merchant-safe first step: open the Scripts customizations report in Shopify admin and export or screenshot what it lists. Developer step: classify each row by behavior type—discount, shipping, payment, line-item transform—and note whether native Shopify discounts could replace it without a Function.
Shopify Functions are not a new Script Editor with a different syntax. They are WebAssembly modules invoked by Shopify during the buyer journey, deployed through apps with versioning, permissions, and Partner Dashboard workflows.
Scripts stopped executing after June 30, 2026. Functions ship inside apps as WebAssembly modules and run during the buyer journey.
| Dimension | Shopify Scripts (deprecated) | Shopify Functions |
|---|---|---|
| Runtime | Ruby in Script Editor | WebAssembly in apps |
| Admin surface | Script Editor textarea | App install + configuration |
| Execution | Checkout (Plus) | Cart and checkout during buyer journey |
| External API calls | Limited patterns | Not at runtime—pre-compute data |
| Status after June 2026 | No longer executes | Current path for checkout logic |
| Plan gate | Plus only | Public app Functions: paid plans; custom apps: Plus |
The migration decision is not 'rewrite every Script in Rust.' It is a portfolio choice: native Shopify discounts, a public App Store app with Functions, or a custom Function app you maintain.
| Path | Best when | Tradeoffs |
|---|---|---|
| Native Shopify discounts | Simple percentage/fixed/buy-X-get-Y rules | No custom logic; limited compared to legacy Scripts |
| Public App Store Function app | Commodity rules (tiered discounts, shipping filters) with merchant UI | App dependency, subscription cost, vendor roadmap risk |
| Custom Function app | Proprietary rules no public app covers | Requires Plus, Partner workflow, ongoing maintenance |
Prefer native discounts when they cover the rule. Prefer public apps for commodity logic with a maintained admin UI. Reserve custom Function apps for rules that are genuinely proprietary and justify development cost.
Plan gating is nuanced. Public apps can expose Functions on lower plans, but individual APIs retain Plus-only capabilities—payment customization with net terms is a common example. Confirm each API's current plan requirements on shopify.dev before you publish a capability table.
Scripts often mixed discount, shipping, and line-item logic in one file. Functions split these into separate APIs that run at specific points in the buyer journey. Conflating them causes double discounts or shipping rules that never fire.
Use the Scripts customizations report as your inventory—then map each rule to the Function API that runs at the same point in checkout.
When external data drives eligibility—ERP inventory, contract pricing, loyalty tiers—pre-compute into metafields or cart attributes before checkout. See the metafields guide for durable data modeling that Functions can read without runtime API calls.
A disciplined migration beats a one-to-one Script rewrite project that recreates rules you stopped needing years ago.
Shopify ties Function API access to completing the checkout extensibility upgrade. If your store still has unmigrated checkout surfaces, resolve that before commissioning Function development. The checkout extensibility guide covers plan gates, pixel migration, and upgrade QA—this article stays on the logic layer.
Engage a Shopify developer when the Scripts report shows proprietary rules native discounts and public apps cannot cover, when payment or delivery customization APIs are required, or when external data must be modeled into metafields for Function consumption. Simple tiered discounts through a reputable public app often need no custom build.
Plus checkout logic projects are app portfolio decisions, not textarea swaps. When Zqdo reviews a Scripts migration, the sequence is report inventory, scope reduction, native discount check, then app vs custom Function—always after confirming checkout extensibility status. Flow belongs in a separate conversation about async ops automation, not as a Scripts replacement.
Shopify Functions replaced Scripts for synchronous checkout and cart logic. Functions are WebAssembly modules deployed through apps. Discount, delivery customization, payment customization, cart transform, and validation APIs each cover different Script types that used to live in Script Editor.
Shopify Scripts were deprecated on June 30, 2026 and no longer execute. Plus merchants should use the Scripts customizations report in admin to see what was active before deprecation and plan recreations via Functions or native Shopify discounts.
Not entirely. Public App Store apps that contain Functions can run on all paid plans. Custom Function apps—apps you build and deploy yourself—require Shopify Plus. Individual Function APIs also have Plus-only features; confirm current API availability before publishing a capability table.
No. Flow runs after store events in admin—it cannot change checkout prices or cart totals during the buyer journey. Checkout-time discount, shipping, and payment logic belongs in Functions or native Shopify discount tools.
No. Use the Scripts customizations report to inventory rules, delete obsolete ones, and check whether native Shopify discounts cover the behavior before commissioning a custom Function. Many Script portfolios include rules that no longer match current merchandising.
Functions run in a deterministic WebAssembly sandbox during checkout. They cannot make outbound network calls at runtime. External pricing or eligibility data must be pre-computed into metafields, cart attributes, or a hosted app backend that syncs before checkout.
Related guides, real Zqdo project examples, and the category hub for deeper exploration.
Agency support · Minion Made
CH Premier Shopify case study—contracted development support for Minion Made on a high-traffic jewelry storefront: Yotpo and Klaviyo integrations, performance, and UX optimization.
Development · UX · Performance · Integrations
View Case Study →
Agency support · Minion Made
American Barbell Shopify case study—contracted development support for Minion Made focused on site performance, customer journey optimization, and strategic ecommerce solutions.
Development · Performance · Customer Journey · Ecommerce
View Case Study →
Featured project
Tushbaby Shopify case study—outsourced web leadership covering performance, CRO, product page architecture, and ongoing web operations with Intelligems A/B testing.
Shopify Consulting & Technical Strategy · CRO · Performance · UX · Product Page Architecture · Ongoing Web Operations
View Case Study →What clients say
Clutch and first-party reviews from merchants who've worked with Zqdo on Shopify development and optimization.
Zqdo builds maintainable Shopify theme, metafield, and custom development solutions that match how your business actually sells.
About the author
Founder & Digital Consultant at Zqdo
David Frempong is the founder and digital consultant at Zqdo. He is a hands-on web developer and Shopify developer who helps ecommerce brands and local businesses improve their websites, integrations, SEO, AEO, analytics, and conversion performance.