Native Shopify order limits: what is and is not possible

Shopify has always been a platform, not a finished product for every business model. The native order limit features cover the basics — but the basics are not enough for most stores running wholesale, case packs, or per-customer rules.

This article breaks down what Shopify can do natively today, where you need theme edits or custom code, and where an app or Shopify Functions becomes the practical choice. No vendor pitch. Just the boundaries as they exist in mid-2026.

What works natively in Shopify admin

Quantity rules on variants (B2B catalogs)

Shopify supports per-variant quantity rules — a minimum, maximum, and increment on how many units a buyer can order. On the storefront they render as a constrained quantity selector, so the buyer cannot type or select outside the range.

The catch is where these rules come from. Quantity rules are set on a B2B catalog, which requires Shopify Plus with B2B enabled. On a standard plan there is no native admin setting to cap how many units of a product a customer can buy — the quantity selector defaults to a minimum of 1 with no maximum.

Even where they apply, quantity rules have limits:

They are set per variant and per catalog, not per product family or collection
The storefront selector is a guide, not a guarantee — the cart API, draft orders, and third-party checkouts can submit quantities outside it
There is no cart-level minimum or maximum (total items, total value)

Order minimum/maximum via Shopify Scripts (now retired)

Shopify Plus merchants used to enforce cart-level rules with Shopify Scripts (Ruby) in the checkout — minimum order value, maximum order value, or a cap on line items. Scripts ran server-side, so they actually blocked the order.

Scripts have since been retired. Editing them stopped in April 2026, and they stopped executing entirely on June 30, 2026. If you find an older tutorial that points to the Script Editor, that path is gone. Shopify Functions are the replacement.

B2B features (Shopify Plus only)

If you are on Plus and have B2B enabled, you get some native wholesale controls:

Company locations with payment terms and catalogs
Quantity rules per catalog (min/max/increment per variant)
Checkout restrictions like minimum order value per company location

These are real, enforced at checkout, and tied to the company profile. But they require Plus + B2B setup, and the rules still live at the variant/catalog level — not collection-wide, not cart-wide, and not with custom logic like "customer tag X gets max 2 of this product."

What requires theme code or storefront edits

Showing limit messages on product pages

You can edit main-product.liquid (or the equivalent section) to display the variant's min/max near the quantity selector. This is display only — it does not enforce anything. If you only need to communicate the rule, this works. If you need to stop the order, it does not.

Hiding add-to-cart for out-of-range quantities

Some themes let you disable the add-to-cart button when the quantity selector is outside the allowed range. Again, this is a storefront guard. The cart API, buy buttons, and headless checkouts bypass it.

Cart page validation (JavaScript)

You can add a script on /cart that reads line item quantities and shows an error if the cart violates your rules. This stops casual buyers. It does not stop:

Accelerated checkouts (Shop Pay, Apple Pay, Google Pay)
Draft orders created by staff
API checkouts from apps or headless storefronts
Buyers with JavaScript disabled

What requires Shopify Functions

Since Scripts are gone, Shopify Functions are the supported way to run custom logic at checkout. For order limits, the relevant one is the Cart and Checkout Validation API. Functions can enforce:

Cart-level minimum/maximum quantity
Cart-level minimum/maximum value
Per-customer or per-tag rules (via customer metafields)
Case pack / quantity increment rules
Product combination rules (e.g., "product A requires product B")

Functions run on Shopify's infrastructure, execute at checkout, and cannot be bypassed from the storefront — including accelerated checkouts like Shop Pay. But:

Plan availability has a catch worth understanding. Functions run on any plan when they ship inside a public app from the Shopify App Store. Building and deploying your own custom Function requires Shopify Plus.
Writing one means building a Function (Rust or JavaScript compiled to Wasm) and deploying it, or installing an app that provides one
Debugging is harder than theme code — you get logs, not a browser console
Each Function has an instruction limit; complex logic across many line items can hit it

What requires an app (any plan)

If you are not on Plus, or you need rules that are easier to configure than code, an order limit app is the practical path. Typical app capabilities:

Rule type	Native (no Plus)	Native (Plus)	Shopify Functions	App
Product min/max	✗	✓ (B2B)	✓	✓
Collection min/max	✗	✗	✓*	✓
Cart quantity min/max	✗	✗	✓	✓
Cart value min/max	✗	✗	✓	✓
Customer tag conditions	✗	✗	✓*	✓
Case pack / increments	✗	✓ (B2B catalogs)	✓	✓
Per-customer limits	✗	✗	✓*	✓
Enforced at checkout	✗	B2B only	✓	✓**

Functions can read customer metafields for tag-like logic, but it is more work to maintain. ** Apps that use checkout UI extensions or Functions enforce at checkout. Apps that only modify the storefront do not.

The Shopify Functions column assumes a deployed Function. Building your own needs Plus, but the same capability inside a public App Store app runs on any plan except Starter — which is why an app is the practical route for most non-Plus stores.

Where the gaps actually hurt

"We just need min $100 for wholesale customers"

Without Plus: you need an app, since building your own Function requires Plus. Theme JS on the cart page is not enforcement.

With Plus but no B2B: you can write a Function that checks cart.attributes or a customer metafield for "wholesale" and enforces minimum subtotal. Or install an app.

With Plus + B2B: catalogs support quantity rules per variant, but not a flat cart minimum. You still need a Function or app for cart-level value minimums.

"Customers can only buy 1 of this limited product"

A quantity selector capped at 1 still lets a buyer:

Add 1, go to cart, update quantity to 5
Use buy button / quick add to add multiple times
Check out via Shop Pay with a saved cart

To actually enforce max 1 per customer per order (or per time period), you need checkout enforcement — Functions or an app with checkout UI extension.

"Wholesale buys in packs of 12, retail buys 1"

B2B catalogs can set increment = 12 for a wholesale catalog, but:

Only on Plus with B2B
Only for customers assigned to that catalog via company locations
Retail buyers on the same storefront are unaffected — there is no native way to hold them to a different rule

For mixed retail/wholesale on one storefront without Plus B2B, you need customer-tag logic at checkout — a validation Function or an app.

"Stop orders over $5,000 for fraud review"

Cart value max at checkout: a validation Function (your own on Plus, or a public app on any plan). No native setting exists for this.

A decision checklist

Your situation	Practical path
Simple product min/max, retail only	Order limit app (native quantity rules need Plus + B2B)
Need cart min/max, on Plus, dev resources available	Shopify Function
Need cart min/max, not on Plus	Order limit app
Wholesale + retail different rules, on Plus + B2B	Catalogs + Functions for gaps
Wholesale + retail different rules, not on Plus	Order limit app with customer tag conditions
Case packs / increments, on Plus + B2B	Catalog quantity rules
Case packs / increments, not on Plus	Order limit app
Time-based limits (max 3 per customer per month)	App with purchase history tracking
Need it this week, no dev capacity	Order limit app

What to ask before committing

Does the rule need to block checkout, or just show a message? If it must block, storefront-only solutions are not enough.
Are you on Shopify Plus? B2B features are Plus-only, and so is building your own Function. A public app that includes a Function runs on any plan except Starter.
Do rules vary by customer group? Standard plans have no native way to vary limits by customer group. B2B catalogs do (Plus). Functions can via metafields. Apps handle it in config.
Do you need collection-level or cart-level rules? Native quantity rules are variant-level and B2B-only. Everything else needs a Function or an app.
Can you maintain custom code? Functions are code. Apps are config. If you do not have a developer on retainer, an app is usually cheaper over time.

FAQ

Can I set a minimum order value in Shopify without an app?

Not natively on any plan. On Plus you can build your own validation Function; on any plan, a public app with checkout enforcement (which itself uses a Function) is the practical route.

Does Shopify have a native "max 1 per customer" setting?

There is no standard-plan setting for this. On Plus with B2B, a catalog quantity rule can set a variant maximum of 1, which limits the quantity selector. Either way, a selector limit does not stop a buyer from adding the product multiple times via cart updates, buy buttons, or accelerated checkouts. For true per-customer enforcement, you need checkout-level logic (a Function or an app).

What is the difference between Shopify Scripts and Shopify Functions?

Scripts were the legacy Ruby-based checkout customization for Plus merchants. They stopped executing on June 30, 2026. Functions are the replacement — Wasm-based and more performant. They run on any plan except Starter when delivered through a public app; building your own requires Plus.