Dynamic Pricing

Dynamic Pricing

Overview

Dynamic pricing automatically adjusts product prices based on demand signals, inventory levels, competitor prices, and business rules. The goal is to maximize revenue per unit sold — raising prices when demand is strong or inventory is scarce, and reducing them to clear slow-moving stock. Most Shopify and WooCommerce merchants accomplish this with a repricing app rather than custom code. Custom implementations are reserved for headless storefronts or merchants with unique repricing logic that apps cannot handle.

When to Use This Skill

• When high-velocity SKUs lose revenue because prices are set-and-forgotten while competitors adjust hourly
• When you need to liquidate slow-moving inventory through automatic markdown schedules
• When running a marketplace where seller prices must respond to competitive pressure
• When building a revenue management system for perishable or time-sensitive inventory
• When A/B testing price elasticity at scale and needing a framework to safely roll out price changes

Core Instructions

Step 1: Determine the merchant's platform and choose the right tool

Step 2: Define your pricing rules before configuring any tool

Before touching any tool, document your guardrails — these prevent the repricing algorithm from making decisions that destroy margin or customer trust:

Step 3: Platform-specific setup

Shopify

Option A: Prisync (competitor-based repricing)

1. Sign up at prisync.com and connect your Shopify store via the integration
2. Add competitor product URLs to track in the Prisync dashboard
3. Set repricing rules: "Match lowest competitor price", "Beat by X%", or "Match and beat"
4. Set your floor and ceiling prices per product
5. Prisync pushes price updates to Shopify automatically on your configured schedule (hourly, daily)

Option B: Shopify Flow (inventory/demand-based, Shopify Plus)

1. In your Shopify admin, go to Apps → Flow
2. Create a new workflow triggered by Inventory level changed or a custom webhook
3. Add a condition: e.g., "Inventory quantity is less than 10"
4. Add an action: Update product variant and set the price to a higher value
5. Add a separate workflow for when inventory recovers to restore the original price

Keep the original prices stored as a product metafield (product.metafields.pricing.original_price) so you can always restore them.

Option C: Third-party apps for demand-based repricing

• Wiser (Shopify App Store): uses sales velocity, add-to-cart rates, and inventory to suggest and apply price changes
• Bold Commerce's Pricing: allows scheduling price changes and automated rules

WooCommerce

Option A: Prisync + WooCommerce REST API

1. Connect Prisync to WooCommerce using the REST API credentials (WooCommerce Settings → Advanced → REST API → Add key)
2. Map your products in Prisync to competitor URLs
3. Configure repricing rules and schedules in Prisync
4. Prisync calls PUT /wp-json/wc/v3/products/{id}/variations/{id} to update prices

Option B: Custom scheduled repricing via WP-Cron

For demand-based repricing in WooCommerce, use a scheduled task:

1. Write a PHP function that checks inventory levels and sales velocity via WooCommerce's order history
2. Schedule it with WP-Cron or a server cron
3. Call wc_get_product()->set_price() and save() to update prices programmatically
4. Log every price change to a custom table for audit and rollback

Option C: YITH Dynamic Pricing plugin

For time-based price changes (scheduled markdowns):

1. Install YITH WooCommerce Dynamic Pricing & Discounts
2. Create rules that apply a percentage discount during specific date ranges
3. This is simpler than full dynamic repricing but covers "end of season" markdown use cases

BigCommerce

BigCommerce's Price Lists feature is ideal for dynamic customer-segment pricing:

1. Go to Products → Price Lists
2. Create price lists per customer group (e.g., "demand_high_inventory_low")
3. Use the BigCommerce Price Lists API to update prices programmatically based on your pricing logic
4. Assign price lists to customer groups via Customers → Customer Groups

For site-wide dynamic pricing without customer segmentation, use the BigCommerce Catalog API to update sale_price on products based on your repricing schedule.

Third-party tools: Linnworks and ChannelAdvisor both integrate with BigCommerce and include competitor monitoring and automated repricing.

Custom / Headless

For headless storefronts, implement a repricing job that runs on a schedule:

import { CronJob } from 'cron';

interface PricingContext {
  productId: string;
  currentPriceCents: number;
  costCents: number;
  inventoryLevel: number;
  salesVelocity7d: number;       // units/day rolling average
  competitorLowestCents?: number; // from price intelligence feed
  floorCents: number;
  ceilingCents: number;
}

function computeNewPrice(ctx: PricingContext): { priceCents: number; reason: string } {
  let price = ctx.currentPriceCents;
  const reasons: string[] = [];

  // Inventory pressure: near stockout → slow demand with a price increase
  if (ctx.inventoryLevel <= 5 && ctx.salesVelocity7d > 0.5) {
    price = Math.round(price * 1.08);
    reasons.push('low_inventory');
  }

  // Slow mover: markdown if no meaningful sales in 7 days
  if (ctx.salesVelocity7d < 0.1) {
    price = Math.round(price * 0.95);
    reasons.push('slow_mover_markdown');
  }

  // Competitor pricing: stay competitive
  if (ctx.competitorLowestCents && price > ctx.competitorLowestCents * 1.05) {
    price = Math.round(ctx.competitorLowestCents * 0.99); // undercut by 1%
    reasons.push('competitor_undercut');
  }

  // Enforce guardrails
  const marginFloor = Math.round(ctx.costCents * 1.15);
  price = Math.max(price, marginFloor, ctx.floorCents);
  price = Math.min(price, ctx.ceilingCents);

  // Only apply if change exceeds 2% threshold
  const changePct = Math.abs(price - ctx.currentPriceCents) / ctx.currentPriceCents;
  if (changePct < 0.02) return { priceCents: ctx.currentPriceCents, reason: 'below_threshold' };

  // Cap single-run change at 20%
  if (changePct > 0.20) {
    const direction = price > ctx.currentPriceCents ? 1 : -1;
    price = Math.round(ctx.currentPriceCents * (1 + direction * 0.20));
    reasons.push('capped_at_20pct');
  }

  return { priceCents: price, reason: reasons.join(',') || 'no_change' };
}

// Run every 30 minutes during business hours
new CronJob('*/30 6-22 * * *', async () => {
  const products = await db.products.findAll({ dynamicPricingEnabled: true });
  for (const product of products) {
    const ctx = await buildPricingContext(product);
    const { priceCents, reason } = computeNewPrice(ctx);
    if (priceCents !== ctx.currentPriceCents) {
      await platformApi.updatePrice(product.id, priceCents);
      await db.priceHistory.insert({ productId: product.id, oldPrice: ctx.currentPriceCents, newPrice: priceCents, reason, changedAt: new Date() });
    }
  }
}, null, true, 'America/New_York');

Best Practices

• Always enforce a floor price tied to cost — compute floor = cost × 1 + min_margin and make it inviolable; no algorithm override permitted below cost
• Store a full price history — every price change needs a row with timestamp, old price, new price, and reason for rollback, audits, and elasticity analysis
• Cap single-run price changes — limit any single job run to ±20% to prevent runaway repricing from bad data or bugs
• Separate recommendation from application — the engine proposes a price; a separate step applies it; this enables human review queues and dry-run mode
• Alert on large automatic changes — send a Slack or email alert when the engine applies a change greater than 10% so a human can review
• A/B test price changes — before rolling out a new price site-wide, run a test on a segment of visitors using the A/B testing pricing skill

Common Pitfalls

Related Skills

• @ab-testing-pricing
• @flash-sale-engine
• @price-rules-engine
• @volume-pricing
• @discount-engine