E-Commerce Price Monitoring: Build Your Own System in 2026

You're losing money every day you don't monitor competitor prices. In e-commerce, pricing is the #1 conversion factor — yet most sellers set prices once and forget them. According to our data from monitoring 130,000+ e-commerce listings, sellers who adjust prices weekly see 18-27% more sales than static-price sellers.

This guide shows you how to build a complete price monitoring system from scratch — from scraping to alerts to automated repricing.

The Real Cost of Not Monitoring Prices

Based on analysis of 130,000 listings across European marketplaces over 90 days:

• 67% of sellers never change their initial price
• Listings with 2+ price adjustments sold 3.2x faster
• The optimal repricing frequency is every 3-5 days for fashion items
• Overpriced items (>15% above market avg) take 4.7x longer to sell

These numbers come from scraping platforms like Vinted across 8 countries using the Vinted Smart Scraper. The pattern is clear: data-driven pricing wins.

Step 1: Define Your Monitoring Targets

Before writing code, decide what to track:

const monitoringConfig = {
  products: [
    {
      name: 'Nike Air Max 90',
      keywords: ['nike air max 90', 'nike airmax 90'],
      brands: ['Nike'],
      minPrice: 20,
      maxPrice: 150,
      sizes: ['42', '43', '44'],
    },
    {
      name: 'Levi\'s 501 Original',
      keywords: ['levis 501', 'levi\'s 501'],
      brands: ['Levi\'s', 'Levis'],
      minPrice: 10,
      maxPrice: 80,
    },
  ],
  markets: ['fr', 'de', 'es', 'it', 'nl'],
  frequency: 'daily',
  alertThreshold: 0.15, // Alert when price drops >15%
};

Step 2: Build the Scraping Pipeline

Use Apify actors to collect pricing data at scale:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

async function collectPriceData(product, market) {
  const run = await client.actor('kazkn/vinted-smart-scraper').call({
    searchQuery: product.keywords[0],
    countryCode: market,
    maxItems: 100,
    minPrice: product.minPrice,
    maxPrice: product.maxPrice,
  });

  const { items } = await client.dataset(run.defaultDatasetId).listItems();

  return items.map(item => ({
    productName: product.name,
    market,
    title: item.title,
    price: parseFloat(item.price),
    brand: item.brand,
    condition: item.status,
    url: item.url,
    scrapedAt: new Date().toISOString(),
  }));
}

async function runFullScan(config) {
  const allData = [];

  for (const product of config.products) {
    for (const market of config.markets) {
      try {
        const data = await collectPriceData(product, market);
        allData.push(...data);
        console.log(
          `✅ ${product.name} [${market}]: ${data.length} listings, ` +
          `avg €${(data.reduce((s, d) => s + d.price, 0) / data.length).toFixed(2)}`
        );
      } catch (err) {
        console.error(`❌ ${product.name} [${market}]: ${err.message}`);
      }
    }
  }

  return allData;
}

Step 3: Store Historical Data

Price monitoring is useless without history. Use SQLite for simplicity or PostgreSQL for production:

import Database from 'better-sqlite3';

const db = new Database('price-monitor.db');

db.exec(`
  CREATE TABLE IF NOT EXISTS prices (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    product_name TEXT NOT NULL,
    market TEXT NOT NULL,
    title TEXT,
    price REAL NOT NULL,
    brand TEXT,
    condition TEXT,
    url TEXT,
    scraped_at DATETIME DEFAULT CURRENT_TIMESTAMP
  );

  CREATE INDEX IF NOT EXISTS idx_product_market 
  ON prices(product_name, market, scraped_at);
`);

function insertPriceData(data) {
  const insert = db.prepare(`
    INSERT INTO prices (product_name, market, title, price, brand, condition, url, scraped_at)
    VALUES (@productName, @market, @title, @price, @brand, @condition, @url, @scrapedAt)
  `);

  const insertMany = db.transaction((items) => {
    for (const item of items) insert.run(item);
  });

  insertMany(data);
  console.log(`Inserted ${data.length} price records`);
}

function getPriceTrend(productName, market, days = 30) {
  return db.prepare(`
    SELECT 
      DATE(scraped_at) as date,
      AVG(price) as avg_price,
      MIN(price) as min_price,
      MAX(price) as max_price,
      COUNT(*) as listings
    FROM prices
    WHERE product_name = ? AND market = ?
      AND scraped_at >= datetime('now', '-' || ? || ' days')
    GROUP BY DATE(scraped_at)
    ORDER BY date
  `).all(productName, market, days);
}

Step 4: Build Alert System

Get notified when prices drop or spike:

function checkAlerts(config, currentData) {
  const alerts = [];

  for (const product of config.products) {
    for (const market of config.markets) {
      const current = currentData.filter(
        d => d.productName === product.name && d.market === market
      );

      if (current.length === 0) continue;

      const currentAvg = current.reduce((s, d) => s + d.price, 0) / current.length;
      const history = getPriceTrend(product.name, market, 7);

      if (history.length === 0) continue;

      const lastAvg = history[history.length - 1]?.avg_price;
      const change = (currentAvg - lastAvg) / lastAvg;

      if (Math.abs(change) >= config.alertThreshold) {
        alerts.push({
          product: product.name,
          market,
          previousAvg: lastAvg.toFixed(2),
          currentAvg: currentAvg.toFixed(2),
          changePercent: (change * 100).toFixed(1),
          direction: change > 0 ? '📈 UP' : '📉 DOWN',
          bestDeal: current.sort((a, b) => a.price - b.price)[0],
        });
      }
    }
  }

  return alerts;
}

async function sendAlerts(alerts) {
  for (const alert of alerts) {
    const message = `${alert.direction} ${alert.product} [${alert.market.toUpperCase()}]\n` +
      `Was: €${alert.previousAvg} → Now: €${alert.currentAvg} (${alert.changePercent}%)\n` +
      `Best deal: €${alert.bestDeal.price} — ${alert.bestDeal.url}`;

    // Send via webhook, email, or Telegram
    console.log(message);
  }
}

Step 5: AI-Powered Insights With MCP

Take your monitoring further by connecting it to the Vinted MCP Server. This lets AI assistants query your price data using natural language.

Install from npm:

npm install vinted-mcp-server

Or clone from GitHub for customization.

Now you can ask your AI assistant things like:

• "What's the average price for Nike Air Max 90 in Germany this week?"
• "Show me products where France is >30% more expensive than Spain"
• "Which products have dropping prices across all markets?"

Performance Benchmarks

Based on our testing with the Vinted Smart Scraper:

Scale	Products × Markets	Listings/Day	Apify Cost/Month
Starter	5 × 3	~1,500	~$5
Growth	20 × 5	~10,000	~$25
Pro	50 × 8	~40,000	~$49
Enterprise	200 × 12	~240,000	Custom

FAQ

How much does it cost to run a price monitoring system?

Based on our benchmarks, a small monitoring setup (5 products across 3 markets) costs approximately $5/month on Apify. The Vinted Smart Scraper charges per compute unit, and most small-scale runs stay well under free tier limits.

Can I monitor prices on platforms other than Vinted?

Absolutely. The architecture in this guide is platform-agnostic. Swap the scraper actor for any marketplace scraper. For mobile apps and app stores, the App Store Localization Scraper provides similar functionality for tracking app pricing across 40+ countries.

How do I avoid getting blocked while scraping?

Use rotating residential proxies and respect rate limits. Apify actors like the Vinted Smart Scraper handle proxy rotation automatically. Keep request frequency reasonable — one scan per day per market is usually safe.

What's the best database for price history?

For small-scale monitoring (under 100K records/month), SQLite is perfect — zero setup, single file. For larger operations, use PostgreSQL with TimescaleDB extension for time-series optimization.

How quickly can I see ROI from price monitoring?

According to our data from sellers who implemented automated monitoring, the average time to first profitable repricing decision was 8 days. Sellers report 18-27% sales increases within the first month of data-driven pricing.

---

Build Your Price Monitor Today

Price monitoring gives you an unfair advantage in any marketplace. Start with a simple daily scan, build up your historical data, and let the numbers guide your pricing.

Try the Vinted Smart Scraper on Apify →

Want AI-powered analysis? The Vinted MCP Server lets you query marketplace data conversationally — GitHub | npm.