If your store is not on Shopify Plus, you can still use most Shopify Function APIs, but only through public apps distributed via the Shopify App Store. Custom apps that contain Function APIs remain a Plus-only capability with no workaround. That single rule, confirmed in Shopify's own documentation and echoed by every error message developers hit on non-Plus stores, defines everything else in this article.
Key takeaways
- Any paid plan can install public App Store apps that contain Functions, covering Discount, Delivery Customization, Payment Customization, Cart Transform, and Cart/Checkout Validation.
- Custom apps (Dev Dashboard, custom distribution) that contain Function APIs are blocked on non-Plus stores. The error is explicit: "Shop must be on a Shopify Plus plan to activate functions from a custom app."
- Two APIs are Plus-only regardless of app type: Order Routing Location Rule (available by request) and the
lineUpdateoperation inside Cart Transform. - Shopify Scripts stopped executing on 30 June 2026. Any merchant whose logic was not migrated to a Function or a public app is now running nothing.
- Distribution type (public vs custom) is a permanent, irreversible choice in the Dev Dashboard. There is no "unlisted public" middle ground that bypasses App Store review for multi-store installs.
The rule, stated precisely
<Shopify's plan rule> is short and unambiguous: stores on any paid plan can install public App Store apps that contain Functions; only Shopify Plus stores can activate custom apps that contain Function APIs.
I have seen this trip up developers who built a perfectly functional app in the Dev Dashboard, tested it on a development store, then tried to activate the Function on a Basic or Advanced client store. The activation mutation returns a hard error. There is no server-side flag to flip and no workaround, as confirmed by Shopify's developer community forums.
What makes this confusing in practice is that the error fires at activation, not at build time. Your Wasm binary compiles fine. The app installs. The GraphQL mutation to activate the Function is what bounces.
Which Function APIs are available to non-Plus stores (through public apps)
| Function API | What it controls | Available via public app on non-Plus? | Notes |
|---|---|---|---|
| Discount (Product, Order, Shipping) | Line discounts, order-level promos, shipping cost discounts | Yes | Unified into a single API since the 2025-04 version |
| Delivery Customization | Hide, rename, reorder shipping methods at checkout | Yes | Up to 25 active per store |
| Payment Customization | Hide, rename, reorder payment gateways | Yes | Up to 25 active per store |
| Cart Transform (lineExpand, linesMerge) | Bundle expansion, line merging | Yes | One active Cart Transform per store total; see note below |
| Cart Transform (lineUpdate) | Override price, title, or image on a line | No | Plus and dev stores only, regardless of app type |
| Cart and Checkout Validation | Block a checkout that violates custom rules | Yes | Returns operations like other APIs since the 2025-07 target rename |
| Fulfillment Constraints | Define how fulfillment groups are created | Partial | Generally available through public apps |
| Order Routing Location Rule | Rank warehouse/location priority per order | No | Plus only, available by request |
The lineUpdate restriction inside Cart Transform is worth reading carefully because most write-ups conflate it with the entire Cart Transform API being Plus-only. That is wrong. lineExpand (split one line into components) and linesMerge (combine lines) carry no such restriction. A Basic-plan store can ship a fully functional bundle-expand-and-merge Cart Transform function through a public app today. The Plus requirement attaches only to price, title, or image overrides on a line.
Similarly, Shopify standardised target and operation names across Function APIs in the 2025-07 version. purchase.cart-transform.run became cart.transform.run, and expand/merge/update became lineExpand/linesMerge/lineUpdate. If you are maintaining a Function that has not been updated to use a 2025-07 or later API version, those renames affect you.
Two distribution types, and why the choice is irreversible
In the Shopify Dev Dashboard you pick one of two distribution paths at app creation:
- Custom distribution: installs on a single store, on all stores within one Shopify Plus organisation, or on transfer-disabled development stores. No App Store review. No Shopify billing API. Function APIs blocked on non-Plus stores.
- Public distribution: lists the app on the Shopify App Store (or as an unlisted public app). App Store review required. Functions activate on any paid plan.
The critical point is that this choice is permanent. An app created as custom distribution cannot be converted to public distribution later, and vice versa. If a developer builds a custom-distribution app containing a Payment Customization Function for a non-Plus client, they will hit the activation error, and their only paths forward are:
- The client upgrades to Shopify Plus.
- The developer builds a separate, new app under public distribution and goes through App Store review.
- The client finds an existing public app in the App Store whose configurable logic covers the requirement.
Option 3 is the right answer for the majority of non-Plus merchants. I have set this up across plenty of stores at non-Plus price points, and the available public apps covering discount logic, delivery method hiding, and payment method reordering are genuinely good. The constraint is not that the functionality is unavailable; it is that the logic cannot be fully bespoke to your exact business rules.
What "publish to the App Store" actually means for a single-store use case
This is the trap developers fall into: thinking that because a public app can be listed as "unlisted" (not shown in search), they can get custom-app-style privacy while unlocking Function access for a non-Plus store. It does not work that way.
An app under public distribution with a non-listed status still requires Shopify App Store review before any merchant can install it. If you are installing on multiple unrelated stores, public distribution is required because custom distribution is scoped to one store or one Plus organisation. Review takes time and requires the app to meet Shopify's partner requirements, including App Bridge, correct OAuth flow, a hosted app URL, and passing automated checks.
For a single non-Plus store that needs a Function, publishing to the App Store solely for that store is a large overhead: you are building and maintaining a publicly reviewed app, with all the compliance that entails, to serve one merchant. The more pragmatic call in that situation is usually: find the nearest public app whose configuration covers the rule, or invest in Plus.
See the glossary entry for Shopify App Distribution for a full breakdown of custom vs public distribution mechanics.
Scripts are gone: what that means for non-Plus stores right now
Shopify stopped allowing Script edits on 15 April 2026 and turned off all Scripts on 30 June 2026. Scripts were Ruby-only and exclusive to Plus. Functions replaced them, are WebAssembly-based, execute in under 5 ms, and cover 11 API types instead of the old three Script types.
The important historical shift: Scripts were a Plus-exclusive tool. Functions through public apps are available on every paid plan. So the net movement from Scripts to Functions actually expanded access for non-Plus merchants, not reduced it. Any merchant whose prior experience was "I cannot do custom discount logic without Plus" should revisit that assumption. The App Store now has Function-based apps for BOGO, volume breaks, free-gift-with-purchase, shipping method hiding, and payment method reordering on Basic-plan stores.
What non-Plus merchants still cannot do:
- Run bespoke, store-specific Function logic without publishing to the App Store.
- Use Cart Transform's
lineUpdateoperation to reprice or retitle a line. - Access the Order Routing Location Rule API.
- Use the Branding API to style checkout via code.
- Place UI extensions inside the Information, Shipping, or Payment checkout steps (those steps remain Plus-only for Checkout UI extensions).
A concrete pattern: Delivery Customization on a non-Plus store
Suppose a client on the Advanced plan needs to hide a specific carrier rate when the cart total is below a threshold. The pattern:
Using a public app (available to any plan): Install a public Delivery Customization app from the App Store. Configure the hide rule through the app's admin UI. The Function runs server-side on Shopify's infrastructure. No hosting, no code ownership.
Using a custom app (Plus only):
// Simplified Delivery Customization Function (JavaScript)
export function run(input) {
const cartTotal = input.cart.cost.totalAmount.amount;
const operations = input.cart.deliveryGroups
.flatMap(group => group.deliveryOptions)
.filter(option => option.title === "Express Shipping")
.filter(() => parseFloat(cartTotal) < 50.0)
.map(option => ({
hide: { deliveryOptionHandle: option.handle }
}));
return { operations };
}
This function compiles to Wasm, activates via the deliveryCustomizationCreate Admin API mutation, and runs in under 5 ms per checkout request. On a Plus store, you own the full logic. On a non-Plus store, that activation mutation will return an error unless the app is under public distribution.
The functional result, hiding a rate below a threshold, is achievable on any plan through a public app. The difference is who controls the exact logic.
Per-store limits worth knowing
Regardless of plan, Function activation has slot limits:
- Most Function APIs: up to 25 active functions per store.
- Cart Transform: one active function per store total. If you install a second app that also registers a Cart Transform, one will be blocked. All bundle expand, merge, and update logic must be consolidated into a single Function per store.
- Order Routing Location Rule: Plus only, available by request, not self-serve.
For stores managing large catalogs (I maintain one with over 10,000 SKUs across a mix of bundle and standalone products), the one-Cart-Transform-per-store limit is the constraint that shows up most. If you have both a bundle app and a free-gift-with-purchase app that each register a Cart Transform, they will conflict. Coordinate with the app developers or switch to one app that handles both operations in a single Function.
Decision framework: which path fits your situation
| Situation | Best path | Why |
|---|---|---|
| Non-Plus store, standard rule (hide rate, BOGO discount) | Public App Store app | Function access on any plan, no code ownership |
| Non-Plus store, bespoke rule not covered by any app | Upgrade to Plus or adapt the rule to fit a configurable public app | No workaround exists for custom-distribution Functions on non-Plus |
| Plus store, rule unique to one store | Custom app, custom distribution | Full logic control, no App Store review overhead |
| Plus org with 3+ expansion stores | Custom app, custom distribution | Installs across all stores in the organisation |
| Developer building for many merchants | Public app, public distribution | Required for multi-store installs; Functions activate on any plan |
| Developer building for one Plus client | Custom app, custom distribution | Faster, no review, no Shopify billing to configure |
Verifying activation
After activating a Function, confirm it is running by calling:
query {
shopifyFunctions(first: 10) {
nodes {
id
title
apiType
app { title }
}
}
}
This query requires the read_functions scope and returns every active Function on the store. Cross-reference against the specific customization type (e.g., deliveryCustomizations) to confirm the Function is registered and not just installed-but-inactive. A Function that compiles and installs but was never activated via its type-specific mutation does nothing.
For a worked example of debugging a Function that installs but silently returns nothing, the post on discount Function debugging patterns covers the exact GraphQL mutations and log-reading workflow.
The bottom line
The plan-access rule for Shopify Functions is simpler than most articles make it. Public apps from the App Store unlock Function-based logic on any paid plan, including discounts, delivery customization, payment customization, Cart Transform (expand and merge operations), and checkout validation. Custom apps with Function APIs require Plus, with no exceptions and no workarounds. Two specific capabilities, Order Routing Location Rule and Cart Transform's lineUpdate operation, are Plus-only regardless of app type. If you are on a non-Plus plan and the available public apps do not cover your exact rule, the choice is adapt the rule to fit a configurable app or upgrade. That is the accurate scope of the constraint.
If you need this built rather than doing it in house, Lintel, the studio I run, takes on Shopify Functions development projects like this.
Frequently asked questions
Can a non-Plus Shopify store use Shopify Functions at all?
Yes, through public apps from the Shopify App Store that contain Functions. Discount, Delivery Customization, Payment Customization, Cart Transform (expand and merge operations), and Cart/Checkout Validation all work on any paid plan through a public app. The restriction applies only to custom apps, which require Shopify Plus to activate Function APIs.
Is there any way to use a custom app with Shopify Functions on a non-Plus store?
No. Shopify's platform enforces this at activation time, not at install time, and returns a hard error stating the store must be on Shopify Plus. There is no flag, workaround, or partner exception documented for non-Plus stores using custom-distribution apps with Function APIs.
What is the Cart Transform lineUpdate restriction, and does it affect non-Plus merchants using public apps?
The lineUpdate operation inside Cart Transform, which lets a Function override a cart line's price, title, or image, is restricted to Plus stores and development stores regardless of whether the app is public or custom. The other two Cart Transform operations, lineExpand and linesMerge for bundle splitting and line combining, have no plan restriction and work on any paid plan through a public app.