Shopware Rule Builder for B2B Pricing 2026: Dynamic Pricing Without Code

Shopware’s Rule Builder lets B2B merchants configure volume-based pricing, customer-group discounts, conditional promotions, and approval workflows entirely through a visual interface – no custom development required. In Shopware 6.5+, these rules execute in real time at the cart and checkout level, covering everything from tiered quantity breaks to currency-specific pricing logic.

Quick Answer: The Rule Builder is Shopware’s built-in conditional logic engine. You define rules using conditions (customer group, cart value, product properties, date ranges, etc.) and then attach those rules to pricing actions, shipping methods, payment options, or promotions. For B2B pricing, this means you can set up volume tiers, negotiated rates, and group-specific catalogs without writing a single line of PHP.

Why This Matters: B2B pricing is inherently more complex than B2C. You’re dealing with negotiated contracts, volume commitments, customer-specific price lists, multi-currency invoicing, and approval chains. Traditionally, this complexity required expensive custom modules or a separate pricing engine. Shopware’s Rule Builder brings most of these capabilities into the admin panel, which dramatically reduces implementation time and ongoing maintenance costs.

Key Takeaways

• Shopware’s Rule Builder supports nested AND/OR conditions across 40+ condition types, enabling complex B2B pricing without code.
• Volume-tier pricing, customer-group discounts, time-based promotions, and minimum order enforcement can all be configured through the admin UI.
• Rules execute server-side in real time, with built-in caching that keeps performance stable even with hundreds of active rules.
• For merchants with more than 500 customer-specific price lists or real-time ERP-driven pricing, a custom pricing engine may still be necessary.
• Combining Rule Builder with Flow Builder unlocks automated approval workflows, notification triggers, and post-order pricing adjustments.

How Shopware’s Rule Builder Works

The Rule Builder operates on a simple principle: define a set of conditions, and Shopware evaluates those conditions at specific trigger points throughout the shopping experience. When conditions are met, attached actions execute automatically.

Architecture Overview

Rules live in Shopware’s rule entity and are evaluated by the RuleScope system. Each scope corresponds to a context – cart scope, order scope, checkout scope, or customer scope. When a customer loads a product page, adds items to the cart, or proceeds to checkout, Shopware checks all active rules against the current scope and applies matching actions.

This happens server-side, which means pricing logic is never exposed to the browser and cannot be manipulated by end users.

Creating Your First Rule

1. Navigate to Settings > Rules in the Shopware admin.
2. Click Add Rule and give it a descriptive name (e.g., “Gold Tier – 10% Discount”).
3. Select conditions from the dropdown. Each condition has its own parameters.
4. Combine conditions with AND (all must be true) or OR (any can be true).
5. Save the rule, then attach it to a pricing action, promotion, or shipping method.

Condition Types

The Rule Builder includes over 40 condition types. Here are the ones most relevant to B2B pricing:

Condition Type	What It Checks	B2B Use Case
Customer Group	Which group the buyer belongs to	Different pricing for wholesale vs retail
Cart Amount (Net)	Total cart value before tax	Minimum order thresholds
Line Item Quantity	Quantity of a specific product	Volume-tier pricing breaks
Line Item Total Price	Total price of a line item	Spend-based discounts on product categories
Customer Tag	Tags assigned to customer profile	Negotiated-rate customers
Date Range	Current date/time	Seasonal pricing, contract periods
Currency	Active currency	Currency-specific pricing rules
Shipping Country	Delivery destination	Region-based surcharges or discounts
Payment Method	Selected payment option	Early-payment discounts
Product Property	Product attributes (size, material, etc.)	Category-specific volume breaks
Custom Field	Any custom field on customer or product	Contract tier, account manager, etc.
Cart Weight	Total cart weight	Heavy-order surcharges
Line Item in Category	Product belongs to a specific category	Category-level promotions
Customer Order Count	Number of previous orders	Loyalty-based pricing
Last Order Date	When the customer last ordered	Re-engagement discounts

AND/OR Logic and Nesting

Rules support nested condition groups. You can create complex logic like:

• (Customer Group = “Wholesale”) AND (Cart Amount > $5,000 OR Line Item Quantity > 100)

This would apply a discount to wholesale customers who either spend above $5,000 or order more than 100 units of any single product. The nesting depth is effectively unlimited, though readability suffers beyond 3 levels.

Rule Priority

When multiple rules match, Shopware applies them based on priority (set in the rule configuration). Higher priority rules take precedence. For B2B scenarios, set customer-specific negotiated rates at the highest priority, volume-tier pricing at medium, and general promotions at lowest.

Real-World Pricing Scenarios

Scenario 1: Tiered Volume Pricing

A manufacturer sells industrial components. Pricing tiers:

• 1-49 units: $25.00 each
• 50-199 units: $21.00 each (16% discount)
• 200-499 units: $18.50 each (26% discount)
• 500+ units: $15.00 each (40% discount)

Implementation: Create four rules, each with a Line Item Quantity condition for the respective range. Attach each rule to a price action that sets the unit price. Set priorities so the highest tier wins when quantities overlap at boundaries.

Alternatively, use Shopware’s built-in “Advanced Pricing” on the product detail page, which lets you set quantity-based price tiers per currency and per customer group directly – no Rule Builder needed for simple cases.

Scenario 2: Customer-Group-Specific Pricing

A distributor serves three customer segments:

• Retail partners: List price minus 15%
• Regional distributors: List price minus 30%
• National accounts: List price minus 42%

Implementation: Create three customer groups in Shopware. Create a rule for each group using the Customer Group condition. Attach each rule to a percentage-based promotion. This approach scales to dozens of groups without performance issues.

Scenario 3: Minimum Order Enforcement

A supplier requires a $500 minimum for wholesale orders but has no minimum for retail.

Implementation: Create a rule with conditions: (Customer Group = “Wholesale”) AND (Cart Amount Net < $500). Attach this rule to block the checkout payment step, and display a message explaining the minimum order requirement. Customers below the threshold see the message but cannot complete the purchase.

Scenario 4: Time-Based Contract Pricing

A B2B customer negotiated a 25% discount valid from January 1 through June 30, 2026.

Implementation: Create a rule with conditions: (Customer Tag = “Contract-2026-H1”) AND (Date Range = Jan 1, 2026 to June 30, 2026). Attach a 25% discount promotion. When the date range expires, the pricing automatically reverts to standard rates. No manual intervention needed.

Scenario 5: Bundle Pricing for Cross-Sells

Customers who order Product A and Product B together get 20% off Product B.

Implementation: Create a rule with conditions: (Line Item in Cart = Product A) AND (Line Item in Cart = Product B). Attach a 20% discount promotion targeted specifically at Product B. This encourages cross-category purchasing without discounting standalone orders.

Scenario 6: Payment-Method Discount

Customers paying by wire transfer (net-30 terms) pay list price. Customers paying by credit card upfront get a 3% discount.

Implementation: Create a rule with the Payment Method condition set to “Credit Card.” Attach a 3% cart-level discount. This offsets processing fees and incentivizes faster cash collection.

Rule Builder vs Custom Pricing Engines

When the Rule Builder Is Sufficient

The Rule Builder handles the vast majority of B2B pricing scenarios out of the box:

• Up to ~200 active rules without noticeable performance impact
• Up to ~50 customer groups with distinct pricing
• Standard volume tiers (quantity breaks on individual products or categories)
• Date-based pricing (seasonal, contract periods, promotional windows)
• Simple approval workflows (when combined with Flow Builder)
• Multi-currency pricing with currency-specific rules
• Region-based adjustments via shipping country conditions

For most mid-market B2B merchants doing $5M-$50M in annual revenue through their Shopware store, the Rule Builder covers 90%+ of pricing requirements.

When You Need a Custom Pricing Engine

Some B2B scenarios exceed what the Rule Builder can handle natively:

• 500+ customer-specific price lists – Rule Builder works but becomes difficult to manage at scale. A dedicated PIM or pricing engine with bulk import capabilities is more practical.
• Real-time ERP-driven pricing – If prices change multiple times per day based on commodity markets, inventory levels, or manufacturing costs, you need a direct ERP integration that overrides Shopware pricing in real time.
• Complex matrix pricing – When price depends on 4+ variables simultaneously (customer, quantity, material, finish, delivery speed, contract tier), the Rule Builder’s nesting becomes unwieldy. A pricing engine with a spreadsheet-style matrix interface is cleaner.
• Bid/quote workflows – If every order requires a custom quote from a sales rep before the customer can check out, you need a CPQ (configure-price-quote) system, not a rule engine.
• Margin-based pricing – If pricing must maintain a minimum margin percentage based on real-time COGS from your ERP, you need a custom middleware that calculates prices dynamically.

Advanced Configurations

Combining Rule Builder with Flow Builder

Flow Builder is Shopware’s event-driven automation system. When combined with Rule Builder, you can create sophisticated B2B workflows:

Approval Workflow Example:

1. Rule: (Cart Amount > $10,000) AND (Customer Group = “Standard Wholesale”)
2. Flow trigger: Order placed
3. Flow action: Set order status to “Pending Approval,” send email to account manager
4. Account manager reviews and approves in admin
5. Flow trigger: Order status changed to “Approved”
6. Flow action: Send confirmation to customer, trigger fulfillment

This gives you a basic approval workflow without any custom plugin development.

Automated Re-Pricing Example:

1. Flow trigger: Customer placed 10th order
2. Flow action: Add tag “Loyalty-Tier-2” to customer
3. Rule: (Customer Tag = “Loyalty-Tier-2”) activates an additional 5% discount
4. Customer automatically gets better pricing on their next order

Nesting Complex Conditions

For advanced scenarios, you can nest condition groups:

Rule: "Enterprise Volume Discount"
  AND Group:
    - Customer Group = "Enterprise"
    - OR Group:
        - Cart Amount (Net) > $25,000
        - AND Group:
            - Line Item Quantity > 500
            - Product Property "Category" = "Raw Materials"

This rule applies to Enterprise customers who either spend over $25,000 or order more than 500 units of raw materials. The visual editor makes this kind of logic accessible to non-developers.

Performance Considerations

Shopware caches rule evaluation results aggressively. However, there are practical limits:

• Rule count: Up to 200 active rules is safe. Beyond 500, expect cart calculation times to increase by 50-100ms.
• Condition depth: Each nesting level adds evaluation overhead. Keep nesting to 3 levels or fewer.
• Product-specific rules: Rules that check Line Item properties are evaluated per cart item. If a customer has 50 items in the cart and 100 product-specific rules, that is 5,000 evaluations per cart load.
• Caching strategy: Rules are cached per customer session. Changing a rule in the admin invalidates the cache globally, so avoid editing rules during peak traffic.

For high-traffic B2B stores (1,000+ concurrent sessions), profile your rule evaluation times using Shopware’s built-in profiler and consider consolidating overlapping rules.

Rule Builder vs Custom: Comparison

Capability	Rule Builder	Custom Pricing Engine
Volume-tier pricing	Yes – native	Yes
Customer-group discounts	Yes – native	Yes
Time-based pricing	Yes – native	Yes
Multi-currency	Yes – with currency condition	Yes
Real-time ERP pricing	No	Yes
500+ price lists	Technically yes, hard to manage	Yes – bulk import
Matrix pricing (4+ variables)	Possible but complex	Yes – spreadsheet UI
Bid/quote workflows	No	Yes (CPQ)
Margin-based pricing	No	Yes
Setup cost	$0 (included)	$15,000-$80,000+
Maintenance	Admin UI, no code	Developer required
Time to implement	Hours to days	Weeks to months

Best Practices

1. Name Rules Descriptively

Bad: “Rule 47” Good: “Wholesale – Volume Tier 3 – 200-499 Units – 26% Off”

When you have 50+ rules, descriptive names are the difference between manageable and chaotic. Include the customer group, the condition type, and the action in the rule name.

2. Document Your Pricing Logic Outside Shopware

Maintain a spreadsheet or document that maps every rule to its business purpose, who approved it, and when it expires. The Rule Builder admin shows you what each rule does technically, but it does not capture the business context behind it.

3. Test Rules in a Staging Environment

Always test new rules in a staging or development environment before activating them in production. A misconfigured rule can silently give every customer a 50% discount – and you will not know until you check the margin reports.

Use Shopware’s built-in test customer feature: create test customer accounts for each group and run through checkout to verify pricing.

4. Set Expiration Dates on Promotional Rules

For any rule tied to a promotion or contract period, always include a Date Range condition. This prevents stale discounts from persisting indefinitely. Review active rules quarterly and deactivate any that no longer apply.

5. Audit Rule Conflicts Regularly

When two rules with different priorities both match a scenario, only the higher-priority rule applies. This is usually correct, but it can also mean a carefully crafted promotion gets silently overridden by a broader rule.

Run a monthly audit: review all active rules, check for overlapping conditions, and verify that priorities are set correctly. Shopware’s admin does not flag conflicts automatically, so this requires manual review.

ROI of Automated Pricing Rules

Developer Cost Savings

Without Rule Builder, implementing even basic volume-tier pricing in Shopware requires a custom plugin. A typical Shopware plugin developer charges $100-$180/hour, and a pricing plugin with volume tiers, group discounts, and date logic takes 40-80 hours to build and test. That is $4,000-$14,400 for the initial build alone, plus ongoing maintenance.

With Rule Builder, a trained admin can configure the same logic in 2-4 hours. At a $50/hour fully loaded admin cost, that is $100-$200.

Savings per pricing scenario: $3,800-$14,200.

Speed to Market

Custom pricing plugins require a development cycle: requirements gathering, development, code review, staging testing, and production deployment. Minimum timeline: 2-4 weeks.

Rule Builder configurations can be created, tested, and activated in the same day. For B2B merchants running promotions or responding to competitor pricing changes, this speed matters.

Error Reduction

Custom code introduces custom bugs. Every pricing plugin is a potential source of calculation errors, edge cases, and rounding issues. Rule Builder’s pricing logic is part of Shopware’s core, tested across thousands of installations. You’re relying on Shopware’s QA instead of your own.

Scalability

As your product catalog and customer base grow, Rule Builder scales without additional development. Adding a new customer group or volume tier is a 10-minute admin task, not a development ticket.

Rule Builder vs Competitor Pricing Engines

Shopware Rule Builder vs Magento 2 Catalog/Cart Price Rules

Magento 2 has separate systems for catalog-level pricing (Catalog Price Rules) and cart-level pricing (Cart Price Rules). This split creates complexity:

• Catalog Price Rules affect displayed prices but do not stack with Cart Price Rules reliably.
• Cart Price Rules use coupon codes by default, which is not ideal for automatic B2B pricing.
• Magento’s condition builder is less intuitive than Shopware’s and lacks nested OR groups without custom code.

Shopware’s Rule Builder unifies all pricing logic in one system. A single rule can affect product display prices, cart calculations, shipping eligibility, and payment availability simultaneously. For B2B merchants, this unified approach is significantly easier to manage.

Edge Magento has: Magento’s ecosystem has more third-party pricing extensions (e.g., Amasty Special Promotions, MageWorx Advanced Product Options) that handle extreme edge cases like buy-X-get-Y across categories.

Shopware Rule Builder vs Shopify Plus Scripts

Shopify Plus uses “Scripts” (Ruby-based) and the newer Shopify Functions (Wasm-based) for custom pricing logic. These are powerful but require developer involvement:

• Scripts run in a sandboxed Ruby environment. Modifying pricing logic means editing code.
• Shopify Functions require building and deploying a WebAssembly module.
• Neither has a visual builder comparable to Shopware’s Rule Builder.

For B2B specifically, Shopify Plus relies heavily on the B2B channel features introduced in 2023-2024, which include company accounts, quantity rules, and price lists. These are improving but still less mature than Shopware’s B2B Suite.

Edge Shopify Plus has: Shopify’s B2B price lists support bulk CSV import natively, which is faster for merchants migrating from spreadsheet-based pricing.

Shopware Rule Builder vs BigCommerce Price Lists

BigCommerce offers Price Lists as a native feature, which lets you assign different price sets to different customer groups. This is conceptually simpler than Rule Builder but also less flexible:

• Price Lists are static – you set a price per product per group, with no conditional logic.
• No volume-tier pricing without a third-party app.
• No date-based pricing, cart-amount thresholds, or payment-method conditions.

For straightforward B2B pricing (fixed group discounts), BigCommerce Price Lists are faster to set up. For anything conditional, Shopware’s Rule Builder is far more capable.

Edge BigCommerce has: Price Lists integrate with BigCommerce’s B2B Edition, which includes quote management and purchase orders – features that Shopware requires plugins for.

Multi-Currency and Tax Scenarios

Currency-Specific Pricing Rules

B2B merchants selling internationally need pricing that accounts for currency differences beyond simple exchange rate conversion. Rule Builder handles this:

Scenario: You sell in USD, EUR, and GBP. Your EUR prices should be 5% higher than the exchange-rate equivalent (to account for EU compliance costs), and GBP prices should match USD 1:1 despite the exchange rate (competitive pricing decision).

Implementation:

1. Create a rule: Currency = EUR. Attach a 5% surcharge promotion.
2. Create a rule: Currency = GBP. Attach a fixed-price override or adjustment.
3. Set base prices in USD. Shopware applies the currency conversion first, then your rules adjust the result.

Tax-Inclusive vs Tax-Exclusive Display

B2B buyers typically expect to see net (tax-exclusive) prices. Shopware supports this at the customer group level, but Rule Builder can add nuance:

• Rule: (Customer Group = “EU Wholesale”) AND (Shipping Country = Germany) – display gross prices (German B2B convention for small orders)
• Rule: (Customer Group = “EU Wholesale”) AND (Shipping Country != Germany) – display net prices

VAT Exemption Handling

For export orders or VAT-exempt customers:

• Rule: (Customer Tag = “VAT Exempt”) AND (Shipping Country within EU) – apply 0% tax rate
• Attach this rule to a tax provider configuration that uses the zero-rate tax

This avoids the need to maintain separate tax configurations per customer and lets the Rule Builder handle exemptions dynamically.

Frequently Asked Questions

Q1: Can I import pricing rules in bulk, or do I have to create each one manually?

Shopware’s admin UI requires creating rules individually. However, you can use the Shopware Admin API to create rules programmatically. This means you can write a migration script that reads pricing data from a CSV or ERP export and creates corresponding rules via the API. Several community plugins also add CSV import/export functionality for rules. For initial setup of 50+ rules, the API approach is strongly recommended.

Q2: How do rules interact with Shopware’s built-in Advanced Pricing (quantity prices on products)?

Advanced Pricing (set directly on the product detail page) takes precedence over Rule Builder promotions for quantity-based pricing. If you set a volume price of $20 for 50+ units on a product, and a Rule Builder promotion would calculate $21, the customer gets $20. Use Advanced Pricing for simple per-product volume tiers and Rule Builder for conditional or cross-product logic.

Q3: Can rules apply to specific products or only to the entire cart?

Both. Rule Builder conditions can target specific products (by ID, category, property, tag, or manufacturer), specific line items in the cart, or the cart as a whole. This means you can create a rule that gives 10% off Product A when the customer also has Product B in the cart, while leaving all other products at full price.

Q4: What happens when a customer qualifies for multiple discount rules?

Shopware applies the highest-priority matching rule. If two rules have the same priority, behavior is undefined – avoid this. For stacking discounts (e.g., 10% group discount plus 5% volume discount), you need to create a single combined rule or use Shopware’s promotion stacking settings, which let you define whether promotions combine or compete.

Q5: Can I restrict payment or shipping methods using the Rule Builder?

Yes. This is one of the Rule Builder’s most powerful B2B features. You can create rules like: (Customer Group = “New Account”) – restrict to prepaid payment methods only. Or: (Cart Weight > 500kg) – only show freight shipping options. Payment and shipping availability rules use the same condition types as pricing rules.

Q6: How does the Rule Builder handle B2B sales tax complexity?

Rule Builder can route customers to different tax configurations based on conditions like shipping destination, customer group, or customer tags. However, it is not a tax calculation engine. For complex tax scenarios (nexus calculations, product-specific tax categories, real-time tax API lookups), integrate a dedicated tax service like Avalara or TaxJar and use Rule Builder to control which tax provider applies to which scenario.

Q7: Is there a limit to how many rules I can create?

There is no hard limit in Shopware’s code. The practical limit is around 500 active rules before you start noticing performance impacts on cart calculation. Most B2B merchants operate well within this range with 50-200 active rules. If you need more, optimize by consolidating overlapping rules and using customer tags instead of individual customer rules.

Q8: Can rules be scheduled to activate and deactivate automatically?

Yes, by including a Date Range condition in the rule. The rule only matches when the current date falls within the specified range. This is the recommended approach for promotional pricing, seasonal adjustments, and contract-period pricing. You do not need to manually activate or deactivate rules – the date condition handles it.

Q9: How do I test rules without affecting live customers?

Use Shopware’s staging environment (available in Shopware Cloud or self-hosted). Alternatively, create a test customer group with test customer accounts and create rules scoped to that group. You can test the entire checkout flow without any risk to real customer pricing. For self-hosted installations, use the built-in sales channel system to create a test storefront.

Q10: Can the Rule Builder handle contract-based pricing where each customer has unique negotiated rates?

Yes, but the approach depends on scale. For up to ~50 customers with unique pricing, create a customer tag per customer (e.g., “Contract-AcmeCorp”) and a rule per tag. For 50-200 customers, use Shopware’s Advanced Pricing with customer-group-specific price tiers. Beyond 200 unique price lists, consider a dedicated B2B pricing plugin or ERP integration that syncs negotiated rates into Shopware’s pricing tables directly, bypassing Rule Builder for this specific use case.

Rule Builder Mistakes to Avoid

Overlapping rules without clear priority. If “10% off for Wholesale” and “15% off for orders over $5,000” both match a wholesale customer ordering $6,000 worth of product, which wins? Without explicit priority settings, the result is unpredictable. Always set priority values and document the hierarchy.

Forgetting to test edge cases. A rule that gives 20% off when cart quantity exceeds 100 sounds simple. But what about a cart with 50 of Product A and 51 of Product B? Does the rule check total cart quantity or per-line-item quantity? Test with realistic cart configurations, not just the happy path.

Creating rules for individual customers instead of using tags or groups. If you have 30 rules that each check for a specific customer email address, you have a maintenance problem. Use customer tags or custom fields to categorize customers, then create rules against those categories.

Not accounting for rule evaluation order in promotions. Shopware evaluates promotion rules in priority order and stops at the first match (by default). If your highest-priority rule is a 5% general discount, customers will never see the 25% VIP discount defined in a lower-priority rule. Promotion execution order matters.

Leaving expired promotional rules active. Even with date conditions, old rules add to the evaluation workload. Deactivate or delete rules once their date range has passed. A quarterly cleanup of expired rules keeps performance optimal and the admin interface manageable.

Take the Next Step

Shopware’s Rule Builder eliminates the development bottleneck that slows down most B2B pricing strategies. Whether you are setting up your first volume-tier structure or migrating complex customer-group pricing from a legacy system, the Rule Builder gives you a production-ready solution in hours instead of weeks.

Start by mapping your current pricing logic to Rule Builder conditions. Identify which scenarios fit natively and which might need a complementary plugin or ERP integration. For most B2B merchants, the Rule Builder alone covers 80-90% of pricing requirements – and the remaining 10-20% can often be handled with Flow Builder automations.

The merchants who get the most value from Rule Builder are the ones who invest time upfront in planning their rule hierarchy, naming conventions, and testing protocols. That foundation pays dividends every time you need to adjust pricing, onboard a new customer tier, or launch a promotional campaign.