Implementing Custom B2B Pricing Rules with Node.js on Shopify

Node.js Middleware for Custom B2B Pricing Rules on Shopify

The most reliable way to implement custom B2B pricing rules on a Shopify store is through a Node.js middleware layer that sits between your storefront and the Shopify Admin API. This gives you precise control over pricing logic per customer segment, without being constrained by what any off-the-shelf Shopify app exposes in its settings.

Why B2B Pricing Rules Outgrow Standard Shopify Apps

Out-of-the-box Shopify pricing tools handle basic discounts and price lists reasonably well for B2C. B2B is a different problem. You often need pricing tied to customer tags, company accounts, negotiated contracts, purchase volume thresholds, or some combination of all of these. A Shopify merchant running wholesale alongside DTC quickly hits the ceiling of what native features and most Shopify apps offer.

More merchants are moving toward middleware-driven architectures for exactly this reason. Instead of bending your business logic to fit a plugin's config screen, you write the pricing rules yourself and expose them through a controlled API layer. The Shopify storefront calls your middleware, your middleware applies the rules, and the cart reflects the correct price. Clean separation, full control.

Why Node.js Is the Right Tool for Shopify App Middleware

Node.js is the practical choice here for a few specific reasons, not just because it is popular.

Its event-driven, non-blocking architecture handles concurrent pricing requests without spawning a new thread per request. In a B2B environment where a single buyer might be checking prices across dozens of SKUs at once, that matters. You get throughput without proportional infrastructure cost.

Integration with Shopify APIs is also straightforward. The Admin API and Storefront API both speak JSON over HTTP, which is native territory for a Node.js and Express stack. You wire up an Express middleware layer that intercepts pricing requests, queries your B2B rules database, and returns adjusted prices in real time. No polling, no overnight batch jobs.

The ecosystem helps too. Libraries for Shopify HMAC validation, rate limiting, retry logic, and TypeScript type safety are mature and well-maintained. You are not building from scratch.

Implementing Custom B2B Pricing Rules: The Core Pattern

1. Set up an Express app with Shopify context

Start with a Node.js and Express application. If you are building a custom Shopify app, use the @shopify/shopify-api package to handle OAuth and session management. For a private middleware service, you can work directly with the Admin API using a simple HTTP client like node-fetch or axios.

2. Validate requests with Shopify HMAC

Every custom endpoint that receives data from Shopify should validate the HMAC signature before processing anything. The Express middleware pattern for this looks like:

import { createHmac } from 'crypto';

function verifyShopifyHmac(req, res, next) {
  const hmac = req.headers['x-shopify-hmac-sha256'];
  const body = req.rawBody;
  const digest = createHmac('sha256', process.env.SHOPIFY_SECRET)
    .update(body)
    .digest('base64');

  if (digest !== hmac) {
    return res.status(401).send('Unauthorized');
  }
  next();
}

This pattern prevents unauthorized requests from reaching your pricing logic on any custom endpoint.

3. Build the pricing endpoint

Create a POST endpoint that accepts a customer identifier (tag, company ID, or account tier) and a list of variant IDs. Your middleware queries your pricing rules, applies the correct logic, and returns adjusted prices. The Shopify storefront or a draft order creation flow can then consume this response.

4. Handle the Admin API sync with a retry queue

If your pricing rules live in Shopify as price lists or metafields, you need a sync job to keep them current. A rate-limited Admin API sync job with a retry queue in Node.js handles this well. Use a library like bull or bullmq backed by Redis to queue sync tasks, respect Shopify's leaky bucket rate limit, and retry on transient errors without hammering the API.

Common Production Challenges

API sync failures are the most frequent issue in production. The Shopify Admin API uses a leaky bucket rate limit. If your sync job does not account for this, it will hit 429 errors during high-volume periods. Build your retry queue with exponential backoff and log every failed job so you can replay them.

Security goes beyond HMAC validation. Lock down your middleware endpoints with IP allowlists if they are only called by Shopify webhooks or your own storefront. Do not expose raw pricing logic endpoints publicly.

Performance at scale requires caching. If your B2B pricing rules change per customer tier rather than per session (which is typical), cache the resolved price for a given customer tag and variant combination. Redis integrates naturally with a Node.js stack and keeps response times low as your catalog grows.

The team at Xavierapps applies these same patterns when building custom Shopify API integrations for merchants who need pricing infrastructure that goes well beyond what a standard e-commerce app can configure.

FAQ

How can I implement B2B pricing rules on my Shopify store?

Build a custom middleware service using Node.js and Express that handles pricing logic based on customer segments and communicates with the Shopify Admin API to apply the correct prices. This approach works for both embedded Shopify apps and headless storefronts. It gives you full control over rule complexity without relying on a third-party app's configuration limits.

Why use Node.js for Shopify app development involving custom pricing?

Node.js handles concurrent API requests efficiently due to its event-driven architecture, which matters in B2B environments with high transaction volumes. The ecosystem around Shopify API integration, HMAC validation, TypeScript, and retry queue management is mature, so you spend more time on business logic and less on infrastructure plumbing.

What are the security best practices for custom B2B pricing rules on Shopify?

Always validate the Shopify HMAC signature on any custom endpoint receiving webhook or storefront data. Rate-limit your Admin API sync jobs and implement a retry queue with proper error handling. Where possible, restrict endpoint access to known IP addresses to reduce the attack surface on your pricing logic.

About Xavierapps

Xavierapps is a full-stack Shopify and web development agency specializing in custom Node.js and React development, React Native, and CRM integrations for merchants who need solutions beyond what standard Shopify apps provide. The team builds custom middleware, API integrations, and headless Shopify architectures for B2B and high-growth e-commerce stores. You can explore their published Shopify apps at the Xavierapps partner store.