---
title: "Dynamic pricing data"
description: "Dynamic pricing data for repricing engines: live competitor prices, stock, delivery fees and offer counts from Amazon, Walmart, eBay and retailers."
canonical: https://www.zenrows.com/use-cases/dynamic-pricing
updated: 2026-10-18
---

# Dynamic pricing data

Dynamic pricing is a strategy where prices change automatically with market conditions such as competitor prices, stock levels and demand. Zenrows supplies the pricing engine's market inputs by fetching competitor pages on demand or in scheduled Batch runs, and returning price, stock and delivery fields as JSON your repricing rules can read.

## Sample output: inputs for one repricing decision

```json
{
  "sku": "HDP-900-WHT",
  "requested_at": "2026-10-17T11:15:02Z",
  "our_price": 189.0,
  "floor": 159.0,
  "ceiling": 219.0,
  "competitors": [
    { "site": "retailer-a.example", "price": 179.0, "in_stock": true, "delivery_fee": 0.0, "captured_at": "2026-10-17T11:15:04Z" },
    { "site": "retailer-b.example", "price": 174.99, "in_stock": false, "delivery_fee": 4.99, "captured_at": "2026-10-17T11:15:05Z" },
    { "site": "marketplace.example", "price": 182.5, "in_stock": true, "offers": 6, "captured_at": "2026-10-17T11:15:06Z" }
  ],
  "lowest_in_stock_delivered": 179.0,
  "competitors_out_of_stock": 1,
  "bestseller_rank": 38,
  "inputs_valid": true
}
```

An illustrative input bundle: competitor fields come from Fetch with CSS selectors; floor, ceiling and the derived values come from your own pricing system.

## What dynamic pricing teams collect

A dynamic pricing engine is only as current as its inputs. Pricing and data teams feed it market signals from competitor pages, and the engine applies your rules within your floors and ceilings.

| Job | Data you collect | Typical sources |
|---|---|---|
| Competitor price inputs | Selling price per matched competitor SKU | Amazon, Walmart, Best Buy, Target, competitor stores |
| Competitor stock-outs | In stock or out of stock, per competitor and variant | Competitor product pages |
| Delivered price | Delivery fee, free-delivery threshold, delivery date | Product and checkout-preview pages |
| Marketplace pressure | Number of offers, lowest offer, featured offer price | Amazon offer listings, eBay, Walmart Marketplace, Mercado Livre |
| Demand signals | Bestseller rank, search position, review count growth | Amazon Best Sellers Rank, retailer search pages |
| Travel and event pricing | Fares, room rates, resale ticket prices by date | Airline sites, Booking.com, StubHub |

## Why dynamic pricing data fails

A pricing engine acts on whatever inputs it receives. A stale price triggers a cut nobody needed; a missing stock flag gives away margin when a rival is sold out.

| What breaks | What it looks like | How Zenrows handles it |
|---|---|---|
| Inputs older than the repricing cycle | The engine reprices hourly on prices captured yesterday | Fetch returns a live page per request; Batch sweeps the full list as often as your cycle needs |
| Stock signal hidden in JavaScript | The "out of stock" label appears only after the page renders | Adaptive Stealth Mode escalates to browser rendering when the page needs it, and a full browser render can wait for the availability element to load |
| Price and stock from an internal API | The page loads price and inventory from a JSON call | Zenrows can capture the page's background network calls (XHR) so you read the values directly |
| Protection at peak hours | Repeated checks from one IP hit challenge pages, often during the sales events when prices move most | Zenrows' stealth gets through protections such as Akamai, PerimeterX (HUMAN), AWS WAF and Cloudflare |
| Unparseable values | A price field returns text such as "See price in cart" and the engine reads zero | CSS selectors name each field, and your validation drops records with a missing or non-numeric price |
| Prices behind a choice | Price depends on size, delivery postcode or configuration | Browser runs the selection in a real browser before reading the price |

## How to feed a dynamic pricing engine

1. **Map inputs to SKUs.** For each SKU, list the competitor URLs, the fields the engine needs, and how fresh each input must be.
2. **Sweep the full list on a schedule.** Submit all competitor URLs to Batch at your repricing cadence, with a webhook so the engine runs as soon as results land.
3. **Check on demand before big moves.** When a rule wants to change a price by more than a set amount, fetch the deciding competitor pages again and confirm.
4. **Validate before you reprice.** Reject inputs with missing prices, odd currencies or a jump outside your expected range, and keep the last good value with its timestamp.

```javascript Node.js
// Node 18+  (save as check-prices.mjs)
const fields = JSON.stringify({ price: ".price-now", stock: ".stock-status" });

async function competitorPrice(url) {
  const params = new URLSearchParams({
    apikey: "YOUR_ZENROWS_API_KEY",
    url,
    mode: "auto", // Adaptive Stealth Mode
    css_extractor: fields,
  });
  const res = await fetch(`https://api.zenrows.com/v1/?${params}`);
  return { url, capturedAt: new Date().toISOString(), ...(await res.json()) };
}

const inputs = await Promise.all(COMPETITOR_URLS.map(competitorPrice));
console.log(inputs);
```

```bash cURL
curl -X POST "https://async.api.zenrows.com/v1/jobs" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "regular",
    "status": "closed",
    "zenrows_params": {
      "mode": "auto",
      "css_extractor": "{\"price\":\".price-now\",\"stock\":\".stock-status\"}"
    },
    "webhook": { "url": "https://your-app.example/webhooks/zenrows" },
    "tasks": [
      { "url": "COMPETITOR_URL_1", "external_id": "HDP-900-WHT|retailer-a" },
      { "url": "COMPETITOR_URL_2", "external_id": "HDP-900-WHT|retailer-b" }
    ]
  }'
```

```bash CLI
npx -y @zenrows/cli init
# Confirm one competitor price before a large move
zenrows extract COMPETITOR_URL --css '{"price":".price-now","stock":".stock-status"}'
# inputs.jsonl: one {"url": "..."} per competitor page, swept each cycle
zenrows batch create inputs.jsonl --wait
zenrows batch results <job-id> --out inputs-results.jsonl
```

```text Claude Code (MCP)
# Connect once
claude mcp add zenrows -e ZENROWS_API_KEY=YOUR_ZENROWS_API_KEY -- npx -y @zenrows/mcp

# Then ask:
Use Zenrows to read the current price, stock status and delivery fee for
the HDP-900 headphones on these five competitor product pages, and return
a table sorted by price with the time each page was read.
```

## Which Zenrows product fits

| If you need to | Use | Why |
|---|---|---|
| Confirm a few competitor prices right before a price change | [Fetch](/products/fetch) | One request per page returns the current price and stock as named fields |
| Refresh every input at your repricing cadence | [Batch](/products/batch) | The full URL list runs as one job, and a webhook tells your engine when it finishes |
| Read prices that depend on a size, postcode or configuration | [Browser](/products/browser) | Playwright or Puppeteer make the selection in a real browser |

## What success looks like

| Measure | What good looks like | How to check it |
|---|---|---|
| Input freshness | Every input used in a decision is younger than one repricing cycle | Log the `captured_at` of each input next to each price change |
| On-demand latency | Confirmation lookups return fast enough to fit inside the repricing run | Track response times per competitor domain and watch the slowest five percent |
| Competitor coverage | Each SKU has inputs from every competitor in its set | Share of SKUs with a complete competitor set per run |
| Input validity | Almost no records reach the engine with missing or implausible values | Count records rejected by validation per run and per domain |
| Stock signal accuracy | Competitor stock-outs are caught within one cycle | Spot-check flagged stock-outs against the live page |
| Sweep duration | A full input sweep finishes well inside one repricing cycle | Compare each Batch job's start and finish times with the cycle length |

## Dynamic pricing FAQ

### What is dynamic pricing?

Dynamic pricing is setting prices that change automatically in response to market conditions: competitor prices, your stock, competitor stock, demand, time of day or season. Retailers, marketplaces, airlines, hotels and ticket sellers use it. A pricing engine applies rules or models to these inputs and changes prices within floors and ceilings you set.

### What data does a dynamic pricing engine need?

External inputs usually include competitor prices, competitor availability, delivery fees and dates, marketplace offer counts, and demand signals such as bestseller rank or search position. Internal inputs include your cost, stock, sales velocity and margin targets. Web scraping supplies the external side.

### How fresh does dynamic pricing data need to be?

At least as fresh as your repricing cycle. If the engine runs every hour, inputs older than an hour can trigger moves the market no longer supports. A common setup is a full sweep at that cadence plus on-demand checks for the competitor pages that decide a price change.

### Should I use real-time requests or scheduled batches?

Use both. Scheduled Batch runs keep every input current at low effort, and a webhook can start the engine when results arrive. On-demand Fetch requests cover single checks, such as confirming a rival's price before a large cut or during a sales event.

### What is the difference between price monitoring and dynamic pricing?

Price monitoring collects and reports competitor prices for people to read. Dynamic pricing acts on those prices automatically. The data is similar, but dynamic pricing needs tighter freshness, validation before each decision, and a record of which inputs led to which price change. See competitor price scraping for the monitoring side.

### How do I match my SKUs to competitor products?

Match on hard identifiers first: GTIN, UPC, EAN or the manufacturer part number, which many product pages carry in their specs or structured data. Where no identifier exists, match on brand, model, size and pack count, and send uncertain matches to a person before they feed the engine. Store each match with the date it was confirmed, and recheck it when a competitor changes the title or images.

### Is dynamic pricing legal?

Changing your own prices in response to the market is legal in most places and common in retail and travel. Some sectors and countries limit price changes during emergencies, require clear display of prices, or restrict pricing based on personal data. Ask your legal team about the rules for your markets.

## Related use cases

- [Competitor price scraping](https://www.zenrows.com/use-cases/price-scraping.md): Competitor prices, promotions, shipping and stock per SKU from retailers and marketplaces, refreshed on your schedule.
- [Hotel data scraping](https://www.zenrows.com/use-cases/hotel-data-scraping.md): Nightly rates, room types and parity gaps from Booking.com, Expedia, Google Hotels and brand sites.
- [Flight price scraping](https://www.zenrows.com/use-cases/scraping-flight-prices.md): Fares, fare classes and award seats by route and date from airline sites and OTAs.
- [Ecommerce web scraping](https://www.zenrows.com/use-cases/ecommerce-web-scraping.md): Product, price, stock, review and seller data from Amazon, Walmart, eBay and Shopify stores, as JSON.
- [Competitive intelligence](https://www.zenrows.com/use-cases/competitive-intelligence.md): Pricing, hiring, reviews, launches and partners across your market, structured for battlecards and strategy.

Start free: https://app.zenrows.com/register. Docs: https://docs.zenrows.com