How to Set Up Quantity Breaks on Shopify (2026): A Tested Setup Guide

What Changed in 2026 (Things Most Guides Got Wrong)

If you read a quantity-break tutorial written before April 2026, three of its core claims are now incorrect:

• Native B2B is no longer Plus-only. On April 2, 2026 Shopify rolled out company profiles, up to 3 catalogs, quantity rules, and volume pricing (up to 10 price breaks per product per variant) to every paid plan — Basic, Grow, Advanced, and Plus. Source: Shopify News, "B2B for All".
• The 25-discount cap includes Functions and apps. Shopify raised the automatic-discount limit from 5 to 25 in November 2024 — but that 25 is a combined total across native automatic discounts, app-based discounts, and Shopify Function discounts. Source: Shopify developer changelog.
• Shopify Plus pricing is $2,300–$2,500/month, not $2,000. $2,300 on a 3-year contract, $2,500 on a 1-year contract, plus 0.25% platform fee on monthly GMV above $1M. Older guides citing "$2,000+/mo" are out of date.

Which Method Should You Use? (30-Second Decision Tree)

Pick the right path before you start clicking. From the stores I've worked with:

For roughly 9 out of 10 DTC stores I work with, the answer is Method 1. The other 10% break down to: B2B sellers (Method 4) and teams with custom logic that no app supports (Method 5).

Pick Your Method by Store Scenario

The decision tree gives you the headline. These scenarios show the nuance — based on what's actually worked across the stores we've onboarded:

All 5 Methods Compared

Method 1: Third-Party App on Shopify Functions (Fastest, Recommended)

Best for: Any DTC Shopify store on any paid plan that wants quantity breaks live in under 10 minutes with a visible pricing table on the product page.

Why it wins for DTC: Modern quantity-break apps (Oxify, Kaching, Pumper, Rapi, Wide Bundles) install as theme blocks, render a pricing table inside the buy box, apply discounts via Shopify Functions, and ship with analytics, A/B testing, and progress bars. Native Shopify gives you none of that on the DTC storefront.

Step-by-step (Oxify as the example — same flow for most apps)

1. Install the app. Go to Oxify Bundles on the Shopify App Store and click Add app. Approve permissions when prompted. Admin path: Apps → Shopify App Store → search "Oxify".
2. Open the app and start a new offer. Apps → Oxify Bundles → Create offer.
3. Choose offer type. Select Quantity Breaks.
4. Pick the products. Specific products, a collection, or all eligible products. Skip loss-leaders and any product under 40% gross margin.
5. Configure three tiers. Tier 1: Buy 2, save 10%. Tier 2: Buy 3, save 15%, badge "Most Popular." Tier 3: Buy 5, save 20%. The 10/15/20 ramp is the most-tested in 2026 — competitors who recommend 5/10/15 are leaving conversion on the table, and 15/25/40 trains shoppers to wait for sales.
6. Style and place the widget. Set colors and badge text to match your theme. In the theme editor (Online Store → Themes → Customize), drag the app's block into the product template below the variant selector and above the add-to-cart button. This placement matters — I'll explain why in the mistakes section.
7. Set the Combinations rule. This is the setting most setups get wrong. In the offer settings, decide whether the tier combines with manual discount codes. If you allow shoppers to use coupons at checkout, set "Combine with product discount codes" to on. (Functions-based apps support stacking; older draft-order apps don't.)
8. Enable the cart-drawer progress bar. "You're $12 from saving 20%" — this single string is worth 8–15% on AOV in our tests.
9. Save and publish. The widget goes live on the selected products.
10. Verify in incognito (mandatory). Open the product page in a private window, add 2 units, and confirm the discount applies in the cart drawer and at checkout.

Why apps beat native methods (the practical version)

• Visible on the product page. Native discounts only show at checkout. If your shopper doesn't know tiers exist when they hit add-to-cart, they bought one unit.
• No per-product configuration tax. One app offer can apply to a whole collection. Native automatic discounts force you to recreate the rule per product/variant.
• Stacks with discount codes (via Combinations). Customers can use a quantity break and an email coupon on the same order. Native auto-discounts can't do this.
• Analytics + A/B testing. Measure tier-level revenue and split-test thresholds. Native admin gives you neither.
• Mix-and-match. Customers combine variants (sizes, colors, flavors) toward a single tier.
• Markets-compatible. Functions respect multi-currency and presentment pricing.

For a full comparison of 10 apps (with verified pricing, ratings, and pros/cons), see our best quantity break apps for Shopify guide.

Method 2: Shopify Automatic Discounts (Free, Limited)

Best for: Stores with 1–2 products that want a quick free option and can live without a product-page pricing table.

The catch: The discount is invisible until cart/checkout. Most shoppers won't know it exists — which means most won't upgrade.

Step-by-step

1. Admin: Discounts → Create discount.
2. Select Amount off products.
3. Choose Automatic discount (applies as soon as cart qualifies — no code).
4. Title clearly. Example: "Buy 2, save 10%." The title appears in cart and checkout — make it the offer description, not internal notes.
5. Set discount value: Percentage, 10.
6. Applies to. Specific products or collections.
7. Minimum requirements. Choose Minimum quantity of items → 2.
8. Customer eligibility. All customers, unless restricting to a segment.
9. Combinations. Decide if this auto-discount combines with product, order, or shipping discounts. Default is "No combinations" — change this if you want shoppers to also use codes.
10. Active dates. Set start date. Optional end.
11. Save. Repeat for tiers 2 and 3 (3 separate discounts).

Hard limits before you start

• 25 active automatic discounts max per store. Includes app-based and Function-based discounts. 10 products × 3 tiers = 30 rules → over the cap. Source: Shopify changelog.
• Only one automatic discount applies per cart by default. If two qualify, Shopify picks one — usually the larger. Enabling Combinations adds complexity.
• No product-page display. Shoppers learn about the discount only when items hit the cart.
• No analytics. Can't measure tier-level revenue or A/B test.
• Doesn't scale. 50 products with 3 tiers = 150 manual discount rules. Will not fit under the 25-discount cap.

Method 3: Manual Discount Codes

Best for: Email-only or influencer campaigns where you control the distribution of the code.

The catch: Customers must enter the code at checkout. Most won't, because they don't know it exists.

Step-by-step

1. Admin: Discounts → Create discount.
2. Select Amount off products → Discount code.
3. Enter a code customers will remember. Example: BUY3SAVE15.
4. Set discount value: 15% off.
5. Applies to. Specific products or collections.
6. Minimum requirements. Minimum quantity = 3.
7. Save. Repeat for each tier.
8. Distribute via email, post-purchase pages, or influencer briefs.

This is the weakest method for in-store conversion — the discount lives outside the product page entirely. Use it only when you have a controlled channel for delivering the code.

Method 4: Native B2B Volume Pricing (Now on All Paid Plans)

Best for: Any Shopify store running wholesale or B2B alongside (or instead of) DTC. This is the biggest change in 2026: Shopify opened native B2B features to every paid plan on April 2, 2026 — you no longer need Plus to get volume pricing.

What's included by plan

Source: Shopify News — B2B for All Plans.

Step-by-step (B2B volume pricing setup)

1. Admin: Markets → Catalogs (note: the path moved here from Products in the Winter '26 edition).
2. Create a catalog or open an existing one. Catalogs are assigned to specific B2B companies / company locations.
3. Click Manage products and pricing.
4. For each product, scroll to Volume pricing → click + Add quantity price breaks.
5. Enter the minimum quantity + per-unit price (or % discount) for each break. Up to 10 price breaks per product per variant.
6. (Optional) Set Quantity rules: minimum, maximum, or required purchase increments.
7. Save the catalog. Assign it to the relevant companies/locations.
8. (Optional) Bulk-import via CSV. Export the catalog, edit volume pricing in spreadsheet, re-import.

Limits to know

• B2B only. Volume pricing applies to catalog buyers, not your DTC storefront.
• No DTC product-page widget. Even on Plus, native volume pricing does not render a tier table on your retail product pages.
• 10 price breaks max per product per variant.
• Price becomes fixed once volume pricing is applied. Catalog-wide percentage adjustments won't apply on top.
• Lowest-price wins across catalogs. If a customer has multiple catalogs with the same product, Shopify displays the lowest price.
• 3-catalog limit on non-Plus. For 500+ wholesale customers, you'll hit the cap and need Plus.

Running DTC + B2B at the same time

This is the most common setup I see: a Shopify store selling both wholesale and direct. Run two parallel systems:

• B2B (this method): Native volume pricing in catalogs for wholesale buyers. Works on any paid plan, up to 3 catalogs.
• DTC (Method 1): A third-party app for storefront tier display.

They don't conflict — B2B catalog pricing applies only to logged-in B2B buyers, the app applies only to the public storefront.

Method 5: Custom Shopify Functions (Developer Path)

Best for: Teams with bespoke discount logic that no off-the-shelf app supports — region pricing, multi-step conditional tiers, loyalty mechanics, etc.

Time investment: 4–8 weeks including build, testing, App Review (for public apps), and deploy.

What Shopify Functions are (and the language tradeoff)

Shopify Functions is the platform API for writing custom checkout logic that runs natively at cart evaluation. Functions are written in any language that compiles to WebAssembly — officially supported: Rust and JavaScript (TypeScript via JS). Rust is roughly 3x faster at runtime than JavaScript, per Shopify's own benchmarks. For public apps or computationally heavy logic, write in Rust; for prototypes or simple logic, JS is fine.

Step-by-step (developer workflow, current as of May 2026)

1. Install Shopify CLI. npm install -g @shopify/cli@latest (single package — older guides referencing @shopify/theme as a separate install are out of date).
2. Set up a Shopify Partner account. Required to deploy Functions.
3. Scaffold a new app. npm init @shopify/app@latest
4. Generate a Function extension. shopify app generate extension → select Function → select Product discount.
5. (Rust path) Install Rust via rustup and add the WebAssembly target: rustup target add wasm32-wasip1
6. Edit the Function source. Open extensions/<your-function>/src/run.rs (Rust) or src/run.js (JavaScript). Implement quantity-tier logic.
7. Test locally. shopify app function run executes against a sample input.
8. Deploy. shopify app deploy
9. Create an automatic discount that uses the Function. Admin: Discounts → Create discount → select your Function from the list.
10. Set Combinations. Decide whether this Function discount combines with product codes / order discounts / shipping.
11. Test in incognito + on real orders. Functions affect checkout production — exhaustive QA before flipping live.

Example: Tiered discount Function (Rust)

// extensions/tiered-discount/src/run.rs
use shopify_function::prelude::*;
use shopify_function::Result;

#[shopify_function_target(query_path = "src/run.graphql", schema_path = "schema.graphql")]
fn run(input: input::ResponseData) -> Result<output::FunctionRunResult> {
    let mut discounts = vec![];

    for line in input.cart.lines.iter() {
        let qty = line.quantity;

        let pct: Option<f64> = match qty {
            q if q >= 5 => Some(20.0),
            q if q >= 3 => Some(15.0),
            q if q >= 2 => Some(10.0),
            _ => None,
        };

        if let (Some(p), output::CartLineTarget::ProductVariant(variant)) =
            (pct, line.merchandise.clone())
        {
            discounts.push(output::Discount {
                targets: vec![output::Target::ProductVariant(
                    output::ProductVariantTarget {
                        id: variant.id,
                        quantity: None,
                    },
                )],
                value: output::Value::Percentage(output::Percentage { value: Decimal(p) }),
                message: Some(format!("Buy {} save {}%", qty, p as i32)),
            });
        }
    }

    Ok(output::FunctionRunResult {
        discounts,
        discount_application_strategy: output::DiscountApplicationStrategy::All,
    })
}

That's the core tier logic. A production build needs input validation, target-product filtering, and a test suite (cargo test in Rust). The official Shopify Functions discount tutorial walks through the full configuration.

Important Functions limits

• 25 active Function-based automatic discounts per store (raised from 5 in November 2024). Each Function counts as one — design tier logic to handle multiple use cases inside a single Function rather than spawning many.
• Instruction limit per Function call. JS Functions hit this sooner than Rust. Keep loops bounded; avoid recursive structures.
• Cold start latency. First invocation per session has ~50–100ms overhead.

When to actually take this path

Only when off-the-shelf apps can't express your logic. For 95% of stores, a third-party app on Functions (Method 1) gets you to the same outcome in 10 minutes instead of 6 weeks.

7 Setup Mistakes I See Constantly

These are the failure modes that show up in our support tickets and App Store reviews across the category — not theory, real recurring issues.

1. Discounts steeper than gross margin allows. A 40% top tier on a 30% margin product loses money on every extra unit. Cap your top tier at (Gross margin %) − 15 percentage points. Use the Oxify Bundle Calculator to model COGS + shipping + payment fees + ad spend per tier.
2. Pricing table below add-to-cart. If it's not in the first viewport on mobile, the shopper bought one unit before they knew tiers existed. Test at 375px width in Chrome DevTools.
3. Overlapping automatic discounts. If two automatic discounts qualify on the same cart, Shopify picks one — usually the larger. The customer who expected the smaller one feels cheated.
4. Wrong Combinations setting. The single most common cause of "the discount disappears when I add my coupon code" tickets. Decide once per offer whether tiers stack with codes, document the policy.
5. Skipping the duplicate-theme test. App widgets sometimes conflict with custom theme CSS. Duplicate the live theme, install the widget there, and only publish after testing both desktop and mobile.
6. Not testing on a real phone. Chrome DevTools mobile mode catches 90% of issues. The last 10% — tap targets, real-device font rendering, scroll behavior in cart drawer — only show up on a phone. 70%+ of Shopify traffic is mobile; this matters.
7. Skipping the verification flow. Adding 2/3/5 units to a cart in an incognito window takes 90 seconds. Skipping it costs the cost of every refund and support ticket from broken orders. Do it before every offer launch.

How to Migrate From Native Discounts to a Quantity Break App

This is the most stress-tested migration path I have. We've moved dozens of stores from native automatic discounts to app-based tiers without losing a single order:

1. Audit your existing automatic discounts. Screenshot or export every active rule.
2. Install the new app, configure but don't publish anything yet.
3. Disable (don't delete) your existing automatic discounts. Discounts → click each → set Inactive. Disabled discounts can be re-activated if you need to revert.
4. Configure the app to match your old tiers exactly. Same products, same thresholds, same discount percentages.
5. Publish to one test product first. Pick the lowest-traffic SKU you have a quantity break on. Verify in incognito for 24 hours.
6. Expand gradually. Add 5–10 products per day to the app's coverage. Watch your support inbox for issues.
7. Wait one clean week. Only delete the disabled native discounts after a full week of clean app data. This is your rollback safety net — don't burn it.

Why this order matters: running both systems live simultaneously without disabling the natives causes double-discounting or unpredictable cart math. Disabling (not deleting) gives you the rollback option.

10-Point Pre-Launch Checklist

I run this every time before publishing a new quantity break. Skip it and you'll find broken tiers in production within an hour.

• ☐ Margin math is positive at every tier. COGS + shipping + payment fees + ad-spend allocation tested against tier price. Net stays above 15% of selling price.
• ☐ Tier thresholds match your basket data. Tier 1 sits one unit above the most common basket size (from Shopify Analytics → Reports → Units per order).
• ☐ Pricing table renders inside the buy box. Below variant selector, above add-to-cart.
• ☐ Mobile placement is in the first viewport at 375px. No scroll required to see tiers.
• ☐ Middle tier is visually anchored. "Most Popular" badge or contrasting background on the target tier.
• ☐ Discount applies in cart and at checkout. Tested in incognito at tier 1, 2, and 3 quantities.
• ☐ Combinations behavior is intentional. Decided whether tiers stack with manual codes; setting matches that decision.
• ☐ Within the 25-discount cap. Active automatic + app + Function discounts total ≤ 25.
• ☐ Analytics tracking confirmed. GA4 / Shopify Analytics events fire on tier selection.
• ☐ Support team briefed. Customer service knows the offer and can answer "why is my discount X?" tickets.

How to Verify It's Working (3-Step QA)

Do these in order, in an incognito window. Takes about 90 seconds total.

Check 1: Product page

• Open the product page in a private browser.
• Confirm the pricing table is visible without scrolling on desktop.
• Resize to 375px in Chrome DevTools mobile mode — confirm visibility.
• Check tier prices, badges, and savings match what you configured.

Check 2: Cart

• Add the tier-1 quantity to cart. Confirm tier 1 discount appears in the cart drawer.
• Update to tier 2 quantity. Confirm tier 2 overrides tier 1.
• Update to tier 3. Confirm tier 3 applies.
• Cart line item shows the discount amount with a savings message.

Check 3: Checkout + order

• Proceed to checkout with tier 2 quantity.
• Confirm the discount appears in the order summary.
• Place a test order using Shopify Bogus Gateway (Settings → Payments → Manage manual payment methods).
• Open the order in Admin → Orders. Discount line item is recorded with the correct amount.

Troubleshooting: 7 Real Issues + Fixes

1. "The discount isn't applying in the cart"

• Confirm the product is inside the offer's product/collection scope.
• Offer is published and active (not scheduled).
• Cart meets the minimum quantity threshold.
• Using automatic discounts? Another auto-discount may be blocking yours — only one applies per cart by default.
• Check your store-wide active-discount count is under 25.

2. "The pricing table isn't showing on the product page"

• Open the theme editor → confirm the app's block is added to the product template.
• Custom theme? Block may need manual placement — most app docs include a snippet for legacy themes.
• "Theme app embeds" is enabled in theme settings.
• Clear browser + CDN cache.

3. "Widget breaks on mobile"

• Test at 375px in Chrome DevTools.
• Overflowing? Check theme container padding and widget max-width.
• Text wrapping awkwardly? Shorten badge labels, reduce padding.

4. "Two discounts conflict at checkout"

• Native automatic discounts allow one per cart by default — Shopify picks the larger.
• To stack a tier with a manual code, set Combinations to allow product discount codes — Functions-based apps support this.

5. "Order analytics don't match app dashboard"

• App analytics measure tier-attributed revenue. Shopify Analytics measures total order revenue.
• Refunds may not deduct from app analytics in real time.
• Cross-reference both — Shopify is GAAP source of truth.

6. "Discounts not applying for Markets / international customers"

• Confirm the discount uses Shopify Functions — Functions respect Markets and presentment pricing.
• Legacy draft-order apps don't play well with Markets. Switch to a Functions-based app.
• Test from a VPN in the target market to reproduce.

7. "Theme conflict — widget styling looks broken"

• Premium themes sometimes inject CSS with !important that overrides app widgets.
• Most apps include a "custom CSS" field — use higher-specificity rules.
• Open a support ticket with the app team — most resolve theme-specific styling within 24 hours.

Advanced Setups

Bulk-importing tier rules via CSV

For native B2B volume pricing (all plans), Markets → Catalogs supports CSV export/import — edit volume pricing in a spreadsheet, re-import. For standard discounts, Shopify Admin has no CSV import for discount rules. Some third-party apps (OC Quantity Breaks, Pareto) ship CSV import for tier rules — useful when you have hundreds of products with unique tier ladders.

Shopify Markets + multi-currency

Functions-based quantity break apps automatically respect Shopify Markets, multi-currency, and presentment pricing. A "Buy 3 save 15%" tier works identically in USD, EUR, and JPY. Avoid apps using legacy draft-order workarounds — they tend to break across currencies. Verify your chosen app's listing explicitly says "Built on Shopify Functions."

Running DTC + B2B on the same store

The setup I'd build on a non-Plus store:

• B2B (wholesale buyers): Native volume pricing in catalogs (Method 4). Up to 3 catalogs on non-Plus, unlimited on Plus. Up to 10 price breaks per product per variant.
• DTC (retail storefront): Third-party app on Shopify Functions (Method 1) with product-page widget, A/B testing, and analytics.

These don't conflict — B2B applies only to logged-in B2B buyers, the app applies only to the public storefront.

Targeting customer segments

Both Shopify automatic discounts and most quantity break apps support customer segmentation:

• VIP customers (lifetime spend over a threshold)
• First-time buyers (encourage larger initial baskets)
• Subscribers (combine with subscribe & save)
• Region (high-margin geographies get steeper tiers)

About the Author

Tarun Kapoor works on Shopify pricing and discount strategy, with hands-on experience across DTC and B2B stores ranging from Basic plans to Shopify Plus. The recommendations in this guide come from production deployments, not hypotheticals. Connect on LinkedIn.

Related Reading

• How to Increase Sales with Quantity Breaks: 11-Step Playbook — the strategy layer above setup.
• 10 Best Shopify Quantity Break Apps in 2026 — apps for Method 1, with verified pricing and reviews.
• Oxify Bundle Calculator — model tier economics before launch.

Frequently Asked Questions

Sources & Further Reading

All facts in this guide were cross-checked against Shopify's official documentation in May 2026:

• Shopify News: B2B for All Plans (April 2, 2026 announcement)
• Shopify Help: Discount types
• Shopify Help: B2B quantity rules & volume pricing
• Shopify developer changelog: Increased limits for automatic Function-based discounts (25 cap)
• Shopify Dev: About discounts
• Shopify Dev: Build a Discount Function
• Shopify Dev: Discount Function API reference
• Shopify Dev: Functions language considerations (Rust vs JS)
• @shopify/cli on npm (current install command)
• Internal: Best Quantity Break Apps for Shopify (2026)
• Internal: How to Increase Sales with Quantity Breaks