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