B2B pricing on Shopify: catalogues, price lists and rules

Nearly every B2B project on Shopify comes down to one question: is your pricing a list, or a calculation?

Shopify handles lists natively and well. Calculations need architecture. Establishing which you have, before anything is built, saves the most expensive kind of rework.

What's native

Catalogues assign a set of products and prices to specific companies. A company sees its catalogue; another company sees a different one.

Price lists within a catalogue set prices either as a percentage adjustment off retail or as fixed prices per product. Both work, and they combine with quantity rules.

Quantity rules per product per catalogue: minimum order quantity, maximum, and increments — case quantities of 12, minimum 24, and so on.

Payment terms per company, so trade customers order on net terms rather than paying at checkout.

That covers a lot of real wholesale operations. Availability sits at the upper end of Shopify's plans, which belongs in the plan decision.

Where it stops

Native pricing struggles when the price is derived rather than stored:

• Volume breaks across a category, not per product. "Any 50 units from this range at tier 2."
• Contract pricing with dates. A negotiated rate valid for a period, then reverting.
• Pricing that depends on the customer's history — annual spend tiers, loyalty rates.
• Rules with exceptions. The list price minus 12%, except these six lines, except during a promotion.
• Cost-plus pricing that moves with your supplier costs.

If any of those describe you, you don't have a price list. You have a pricing engine, and it almost certainly already exists in your ERP.

The pattern that works

Calculate in the ERP. Store in Shopify. Read at render and at checkout.

Concretely:

1. Your ERP calculates each company's price for each product, using the rules it already implements.
2. An integration writes those prices into Shopify — as a price list where the model fits, or into metafields where it doesn't.
3. The theme reads them to display the right price.
4. A Shopify Function applies them at checkout, so the price is enforced rather than merely displayed.

Step four matters. A price shown in the theme but not enforced in the cart is a discount waiting to be exploited.

And remember a Function has no network access — it can only read what's already in the cart or in metafields. That constraint is why step two exists.

Who owns the price

The decision to make before writing any code, and the one that prevents most integration failures.

If the ERP owns price, merchandisers must not be able to edit it in Shopify — or the two systems will disagree and nobody will know which is right. Enforce it: the integration overwrites, and the team knows where to make changes.

One owner per field, written down. It's the underlying principle of every integration and it's the thing skipped most often.

Showing prices to the right people

Three common requirements:

• Hide prices until logged in. Theme logic on the customer's company association.
• Show retail and trade side by side so the saving is visible.
• Different catalogues for different companies, which is native.

The first is worth thinking about commercially rather than technically: hiding prices costs you the customers who were browsing anonymously before committing.

Minimums and increments

Native quantity rules cover most of it. Where they don't — a minimum order value per company, a mixed-case rule, a restriction on combining certain lines — that's cart validation with a Function, reading the company's rules from a metafield.

What to decide before quoting

Answer these and a B2B quote becomes meaningful rather than a guess:

1. Is the price a stored list, or calculated from rules?
2. Where do those rules live today?
3. How many companies, and how many distinct price points?
4. How often do prices change?
5. Who is allowed to change a price, and in which system?
6. Does the price need enforcing at checkout, or only displaying?

Question one determines the architecture. Question five determines whether it stays correct.

If your pricing fits in a spreadsheet, Shopify does it natively. If it needs a formula, Shopify displays it and your ERP calculates it — and pretending otherwise is how B2B projects overrun.