Starting April 15, 2026, editing and publishing new Scripts stopped. On June 30, 2026 – Scripts stop running completely.
Businesses have more time to replace Scripts with Shopify Functions - but the migration still needs a clear plan.
What does it mean for a vast audience? It’s actually good news: Shopify’s planning to take ecommerce customization further. Soon, it will cover more aspects and become more accessible to online store owners.
In this article, we’ll tell you more about Shopify Functions that come to replace Scripts, their highlights, and benefits. You’ll also find a brief guideline on migrating to Shopify Functions. It'll help your team understand the changes better and start planning the update. So read on to make sure you don’t miss anything important in the migration steps.
Shopify Scripts vs Shopify Functions
Unlike Scripts, using Shopify Functions doesn't require a Shopify Plus store. Moreover, you no longer need Shopify Plus for every B2B setup. Basic, Grow, and Advanced plans now include key B2B wholesale features. It'll be available for all merchants.
Additionally, Shopify Functions offer a broader scope of customization opportunities.
For example, Shopify Scripts work only with the checkout process and are written exclusively in Ruby. Shopify Functions’ usage won’t be limited to a specific language or functionality. They can be integrated into various apps. This would allow merchants to manage and configure what they need via familiar and convenient interfaces.
Thus, you get more management flexibility. In Shopify Scripts, the data changes must be provided from within the script. Simply put, you can hardly edit anything without basic programming knowledge. Now, teams get more control over backend functionality without interacting with it directly.
Other features make the platform more powerful and flexible in this new edition. Here are a few things that will make you eager to migrate from Shopify Scripts to Shopify Functions.
| Shopify Scripts | Shopify Functions | |
|---|---|---|
| Availability | Shopify Plus merchants only | Stores on any plan can use public apps with Functions, but only Shopify Plus stores can use custom apps that contain Shopify Function APIs. |
| Purpose | Customizing checkout, discounts, and shipping methods | Extending backend logic for various store operations |
| Language | Ruby | WebAssembly (Wasm); Rust is recommended, JavaScript/TypeScript also supported |
| Application | Directly within Shopify’s checkout and cart flow | Backend environment, affecting various parts of the store |
| Ease of use | Requires knowledge of Ruby and the Script Editor interface for development and management | Requires knowledge of Rust (recommended) or JavaScript/TypeScript compiled to WebAssembly for custom development; no coding required when using pre-built apps |
| Testing | Within the Script Editor, changes apply directly | In a development/staging environment before going live |
| Integration | Limited to checkout, cart, and shipping methods | Full Shopify ecosystem, various apps & store operations |
| Customization | Checkout experiences | Multiple aspects of the store |
| Community | Smaller community of Shopify Plus merchants | Larger community, more shared resources, and third-party apps |
| App development | Limited scope for app monetization | Opportunities for creating and monetizing apps with custom backend logic |
| Potential | Limited future enhancements and updates | Actively developed with continuous updates and new features |
So, Shopify Functions focus on a broader functionality and are easier to use. With better versatility and accessibility, they replace what becomes a legacy solution next month. Hence, Shopify scripts to Functions migration isn’t a burden but rather a push towards new opportunities.
Why migrate to Shopify Functions
In June 2026, Shopify Scripts will be deprecated and no longer supported. Merchants can migrate to Shopify Functions or be left without some customization options. The migration will come with multiple benefits.
- Increased flexibility. Shopify Functions allows merchants to extend and customize the backend logic of their stores. It’ll be possible to set up custom discounting rules, unique shipping calculations, personalized checkout experiences, and more.
- Easier scalability. Shopify Functions are designed to handle complex logic. This ability makes them suitable for growing businesses. Extensive customization won’t compromise performance, even when paired with a quickly growing tech stack and data volume.
- Full integration. Functions integrate seamlessly with other Shopify’s features and apps. Merchants get an uninterrupted and wholesome environment for managing their store operations. It’ll simplify workflows and enhance overall efficiency.
- Safer deployment. Teams can develop and test Shopify Functions in a staging environment before deploying them to the live stores. This allows for thorough testing to ensure functionality meets all requirements. You get to minimize the risk of defects and downtimes.
- Easier exploitation. Shopify Functions is installed as part of an app and configured alongside other features directly in a merchant’s admin panel. It means quicker and simpler adjustments with less reliance on the technical team. It can become an opportunity for some teams to spend less on maintenance.
- Better performance. Shopify Functions run on Shopify's own infrastructure powered by WebAssembly (Wasm), a high-performance sandboxed runtime. This guarantees near-native execution speed alongside strong scalability. Online stores can handle large user flows, keeping all pages loaded quickly. This applies to regular days, big sales, and the holiday shopping season.
- Digital security. WebAssembly's sandboxed execution model also comes with solid built-in security features. Moreover, Shopify Functions allow merchants to configure access. You can set up the solution to access only the necessary tech data, keeping customer information safe.
Shopify Function is a solution for businesses of all sizes. Whether you run a small store or a marketplace, it offers ways to customize both.
Which Shopify Script should move to which Function API?
Before you migrate from Shopify scripts to Shopify functions, don’t treat every Script as one generic checkout customization. Start by checking what the Script actually changes: discounts, cart items, checkout rules, shipping methods, or payment methods. Shopify now maps these Script types to specific Function APIs, so this part should be practical, not theoretical.
Here's the simplest way to frame it:
- Line item scripts for discounts should move to the Discounts API. This covers product discounts, cart-level discounts, and custom discount logic.
- Line item scripts that change cart items should move to the Cart Transform API. Use this for Shopify bundles, merged items, added items, or cart structure changes.
- Line item scripts that block or validate checkout should move to the Cart and Checkout Validation API. This works for rules that stop checkout when the cart does not meet certain conditions.
- Shipping scripts usually move to the Delivery Customization API. If the script also applies shipping discounts, it may need the Discounts API too.
- Payment scripts should move to the Payment Customization API. This is where hiding, renaming, or reordering payment methods now belongs.
This mapping helps merchants migrate to Shopify functions with fewer guesses. Instead of rewriting old Ruby logic line by line, the team can decide whether each customization needs a ready-made app or a custom Function. Shopify also recommends using the Scripts customizations report in the admin to review active payment, shipping, and product discount customizations before rebuilding them.
When migrating to Shopify functions, it’s also worth checking whether old Scripts still make sense. Some rules may be outdated, duplicated by newer Shopify settings, or better handled by an app. The goal isn’t only to replace Scripts before the deadline – it's to clean up checkout logic before old customizations stop working on June 30, 2026.
How to migrate from Shopify Scripts to Shopify Functions
It may seem that Shopify leaves no option for Plus members rather than migrating to Shopify Functions. But let’s be fair: there’s more than enough time to prepare for the changes. Moreover, being a user-oriented platform, Shopify made the migration easy.
The DigitalSuits team is ready to assist you with the migration process. Contact our team if you want us to handle this for you. For now, we’re leaving a brief guideline on switching from Scripts to Functions.
Step 1. Audit your existing Scripts
Start Shopify Scripts to Functions migration in your Shopify admin with the Shopify Scripts customizations report, which was rolled out alongside the April 2026 deprecation reminder. It enumerates every active Script in your store and flags which ones can be replaced by an existing public app from the Shopify App Store versus which need custom Function development. That single report typically removes a week of manual inventory work.
For each Script, write down three things: what it actually does, what depends on it (apps, themes, third-party integrations), and what part of it is visible to the customer (discount messaging, shipping label text, payment method names). Customer-visible behavior is what your QA has to verify after the cutover.
Step 2. Map each Script to the right Function API
Shopify Functions are split into separate APIs by purpose, so a single Script may map to one or two Function APIs depending on what it does.
| Script type | Replace with | Use case |
|---|---|---|
| Line item Scripts | Discounts API | Apply discounts to products or the whole cart |
| Line item Scripts | Cart Transform API | Bundle, merge, or add items to the cart |
| Line item Scripts | Cart and Checkout Validation API | Block checkout under specific conditions |
| Shipping Scripts | Delivery Customization API + Discounts API | Hide, rename, or reorder shipping methods; discount shipping rates |
| Payment Scripts | Payment Customization API | Hide, rename, or reorder payment methods |
A few behavior differences worth catching early. In Delivery Customization, the carrier name is automatically prepended to the delivery option title and can't be removed, so if your current Script renames "UPS Standard" to just "Standard," that exact result is no longer possible. The change_properties line-item method has no direct Function equivalent; line item property edits now belong to checkout UI extensions via applyAttributeChange. Discount-code rejection moved to the enteredDiscountCodesReject operation with custom error messages.
Step 3. Choose your build path
You have three options, in increasing order of cost and effort.
- Install a public app from the Shopify App Store. Available on any Shopify pricing plan. If the customizations report flags an app match for one of your Scripts, this is the fastest route and needs zero developer time.
- Use a Shopify Partner-built app. Same accessibility as public apps, but with the option of custom configuration tailored to your business logic.
- Build a custom app with Function APIs. Shopify Plus only. Required when no app fits, and you need bespoke logic.
For option 3, write your Functions in Rust (not JavaScript), despite what older guides recommend. JS Functions compile to WebAssembly through Shopify's Javy toolchain, but they hit Shopify's instruction-count limits noticeably sooner than Rust equivalents, especially on carts with many line items or computationally heavier logic.
JavaScript and TypeScript are still supported and fine for prototyping, but anything that ships in a public app or runs against high-volume carts should be Rust. If your team already has JavaScript Functions, the Shopify Dev Assistant (and the shopify.dev MCP server) can convert them to Rust automatically. This is a feature that didn't exist a year ago and is worth using.
Step 4. Set up and develop locally
Install the latest Shopify CLI and create a development store. Generate the Function scaffold with shopify app generate extension and choose your language. Your input query lives in run.graphql; your logic lives in src/run.rs. Local testing with shopify app function run catches most issues – invalid output shapes, schema mismatches, instruction overruns – before anything touches a real store.
Step 5. Test in production, alongside the live Script
This is the part that's changed most. Instead of validating only in a dev store and cutting over blindly, Shopify now documents a production-safe parallel-testing flow:
- In Apps → Script Editor, save (but don't publish) a temporary passthrough script with the body Output.cart = Input.cart. Note the preview URL that Script Editor generates for that draft. Opening that URL in a customer session effectively disables your published Script for that session only.
- Inside your Function code, add a check on customer tags – for example, only run the new logic when the buyer has the TESTER tag. Tag your QA team and a handful of internal accounts.
Tagged users opening the preview URL hit the new Function. Everyone else continues to hit the live Script as normal. You get real traffic, discount calculations, shipping rates, and payment methods – without exposing existing customers to a half-finished migration.
Step 6. Cut over
Once the tagged-user behavior matches what your Script does today, remove the tag-based conditional from your Function code and redeploy with shopify app deploy. Then, in the admin, unpublish the corresponding Script in Script Editor.
Do these two actions close together. While the ungated Function and the published Script are both live, behavior on overlapping carts can be unpredictable; the goal is to minimize that window to minutes, not days.
Step 7. Monitor and accept that the rollback option is limited
Watch performance and error logs for the first two weeks. WebAssembly Functions run under instruction-count and runtime limits; if a Function exceeds them, it fails for that checkout, and the symptom is usually subtle ("the discount just stopped applying" rather than a visible error). Put alerts on conversion rate and average order value for the affected flows so any drift surfaces quickly.
A wrinkle older migration guides don't mention: since April 15, 2026, you can no longer publish new Scripts or edit existing ones. Once you unpublish your old Script in Step 6, republishing it as a rollback is not guaranteed to work – and after June 30, it stops executing regardless.
Monitoring isn’t only about problems. It’s also a mechanism for growth. Review the performance of the new functions and look for areas for improvement. Feedback from users and stakeholders will also be useful here. Continuous optimization helps maintain a high-quality user experience and, consequently, increase customer retention.
Post-migration is mostly about maintenance. Maintenance entails getting documentation and processes in order – in accordance with the store’s new version. Make sure to update the technical documentation to reflect the new setup. If needed, provide extra training for your team. It will ensure everyone is on the same page and able to work with the new system.
Finally, you can decommission old scripts. Once you are confident that everything works as intended, removing the old Shopify Scripts is safe. Run a final check to confirm no dependencies are left, nothing is broken, and the store operates correctly without the old code. With this step, transitioning to Shopify Functions is officially over.
To sum up
Migrating from Shopify Scripts to Functions can seem daunting initially. However, with a detailed plan in place, it isn’t as complicated as one may suppose. Shopify intends to make any changes as painless as possible for its users. This applies to both businesses and shoppers. Therefore, you can rest assured that the platform is focused on simplifying the technical aspects of this transition.
The Shopify Scripts and Shopify Functions migration process itself is rather standard. Merchants analyze the dependencies, prepare a plan, and back up data, which makes it safe to migrate. Depending on the configuration, you may need custom development or simply connect alternative applications from the Shopify App Store – built on Functions instead of Scripts. Then follow testing, deployment, and monitoring to finalize the migration.
If you have in-house Shopify developers, they can follow the steps above to ensure a smooth transition to the new solution. If not, contact DigitalSuits, and we’ll migrate your shop with minimum disruption or trouble for your team.
Frequently asked questions
Are Shopify Functions for Shopify Plus only?
No, Shopify Functions are available to merchants on all plans, including the lowest Basic Plan. However, only stores on a Shopify Plus plan can use custom apps that contain Shopify Function APIs.
Simply put, merchants can use Shopify Functions as a part of public or partner apps. Standard plans work with Shopify Functions through apps available in the Shopify App Store or built by Shopify Partners. If you want to create or use a custom app, you need Shopify Plus.
Can Shopify Scripts and Shopify Functions be used together?
Yes. Shopify Scripts and Shopify Functions can run in the same Shopify store until June 30, 2026. This gives merchants time to replace old Scripts gradually instead of changing everything at once. After that date, Scripts will stop working, so any active line item, shipping, or payment logic must move to Shopify Functions or a compatible app.
However, they don't work as fully separate layers. Shopify has specific interaction rules. Line item scripts run before Shopify Functions, so they can’t read discounts already applied by Functions or apps. They can also access only the first discount code added to checkout.
Shipping scripts run after delivery customizations created with Shopify Functions. They can still work with delivery methods that Functions move or hide, but not with methods renamed by a Function.
Payment scripts follow a similar rule. They run after payment customizations and can work with payment methods that Functions move or hide, but not with renamed payment methods.
So, the answer is: yes, they can work together for now, but every overlap should be tested carefully before the old Scripts are disabled.
Will migrating to Shopify Functions cause any downtime for my store?
DTC or B2B customers shouldn’t experience any downtime during the migration process. However, the downtime might be caused by some integrations and customizations you have in your store. Hence, it’s better to consider it as a risk in your migration strategy.
One way to handle it is to transition your customers in small batches. However, transitioning all at once is also an option. Just make sure to inform them about maintenance works to avoid accidents and dissatisfaction.
Written by
Yurii Zablotskyi
Content Marketing Specialist
Yurii Zablotskyi is a passionate content writer and storyteller with a strong marketing background, focusing on marketing, sales, and technology, turning complex ideas into valuable content.
Was this helpful?
0
No comments yet