Competitor Price Monitor & Repricing for Shops

Competitor price monitoring for your own catalog: paste your products with your price (and cost), add the competitor product URLs from any shop (Shopify, WooCommerce, Magento, custom), and get one row per product with the lowest competitor price, your price gap, change since the last run and a safe repricing suggestion that respects your floor price, minimum margin and maximum change. Optionally push the new prices to Shopify, WooCommerce or any platform through a webhook.

Built for small and mid-size web shops, marketplace sellers and e-commerce agencies who want a daily price tracker without a $100/month repricing SaaS. You only pay for pages where a price was found: blocked pages, pages without a price, summaries and suggestions are free.

• Any product URL: prices are read from Shopify's public product JSON, schema.org JSON-LD (Product / Offer / AggregateOffer / ProductGroup variants), microdata, OpenGraph / product meta tags and WooCommerce price markup.
• Your price vs theirs: gap in money and percent, cheapest / equal / above-lowest position, min / average / max.
• Repricing rules: match the lowest, undercut by % or amount, or stay a % above. Guards: floor price, minimum margin on cost, maximum change per run, "never raise", ignore out-of-stock and other-currency offers.
• Price history: every scheduled run compares with the previous one (price drop, price increase, back in stock, out of stock) using a named key-value store in your account.
• Three modes: Monitor only, Suggest (you approve each price) and Automatic (rules decide; shop push only when you switch it on).
• EU-ready: 1.299,00 €, 12,-, 1 299,00 kr, CHF 1'299.90, and 1,299.00 all parse; currency is detected and never mixed.
• Polite and legal by design: real user agent, robots.txt respected, one request at a time per shop, timeouts. The Actor never bypasses captchas or bot protection: blocked pages are reported as blocked and not charged.

How it works

1. Add your products (in the input, or as a JSON / CSV feed URL, e.g. a Google Sheet published as CSV).
2. For each product add one or more competitor product page URLs.
3. Run it once, check the Overview table, then schedule it daily (Console -> Schedules).
4. Read the suggestions in the Repricing view, or let Automatic mode push approved rules to your shop.

Your catalog ──► competitor pages (HTTP, polite) ──► price + currency + stock
                                                        │
       your price / cost / floor ──► rules + guards ──► suggested price ──► (optional) Shopify / WooCommerce / webhook

Input

Field	What it does	Default
products	Your products: sku, name, yourPrice, currency, optional costPrice, floorPrice, ean, yourUrl, and competitors (URLs or {name, url})	3 demo products
catalogUrl	Public JSON or CSV feed with the same fields (see below)	-
mode	monitor, suggest or auto	suggest
strategy	undercut_percent, undercut_amount, match_lowest, premium_percent	undercut_percent
undercutPercent / undercutAmount / premiumPercent	Strategy parameters	2 / 1 / 5
minMarginPercent	Never below cost / (1 - margin); 0 = never below cost	0
floorPrice	Never below this (a product's own floorPrice wins)	-
maxChangePercent	Max move from your current price per run	15
allowPriceIncrease	Suggest raising when competitors are more expensive	true
ignoreOutOfStock	Out-of-stock offers don't drive suggestions	true
maxProducts / maxCompetitorsPerProduct	Safety caps	100 / 10
pushToShop + shopPlatform	Write prices (Automatic mode only)	off
shopifyDomain, shopifyAccessToken🔒	Shopify custom app (scope write_products)	-
wooBaseUrl, wooConsumerKey🔒, wooConsumerSecret🔒	WooCommerce REST key (Read/Write)	-
webhookUrl🔒, webhookSecret🔒	Any platform via Zapier / Make / n8n / your backend	-
markets	(Beta) competitor shops to search by EAN / name	-
respectRobotsTxt, maxConcurrency, requestTimeoutSecs, proxyConfiguration, historyStoreName	Advanced	true, 5, 20, off, competitor-price-monitor-history

🔒 = secret field: stored encrypted by Apify, never written to the dataset, the logs or the key-value store (every output is scrubbed for these values as an extra safety net).

Example input

{
  "mode": "suggest",
  "strategy": "undercut_percent",
  "undercutPercent": 2,
  "minMarginPercent": 30,
  "maxChangePercent": 10,
  "products": [
    {
      "sku": "RUNNER-42",
      "name": "Trail runner",
      "yourPrice": 129.95,
      "currency": "EUR",
      "costPrice": 62,
      "ean": "8712345678906",
      "competitors": [
        { "name": "Shop A", "url": "https://shop-a.example/products/trail-runner" },
        { "name": "Shop B", "url": "https://shop-b.example/product/trail-runner/" }
      ]
    }
  ]
}

CSV feed

Comma, semicolon or tab separated; one row per competitor (rows with the same sku are grouped), or wide columns competitorUrl1, competitorUrl2, .... EU number formats are fine.

sku;name;yourPrice;currency;costPrice;competitorName;competitorUrl
RUNNER-42;Trail runner;129,95;EUR;62;Shop A;https://shop-a.example/products/trail-runner
RUNNER-42;Trail runner;129,95;EUR;62;Shop B;https://shop-b.example/product/trail-runner/

For shop push add variantId (Shopify variant ID) or shopProductId / shopVariationId (WooCommerce) columns. Leave yourPrice empty and fill yourUrl to read your current price from your own product page.

Output

One dataset row per product, with the competitor offers nested in competitors. Three table views: Overview (one row per product), Competitor offers (one row per page) and Repricing.

{
  "sku": "RUNNER-42",
  "name": "Trail runner",
  "yourPrice": 129.95,
  "currency": "EUR",
  "lowestCompetitor": "Shop B",
  "lowestPrice": 119,
  "lowestPriceChange": -5,
  "gap": 10.95,
  "gapPercent": 9.2,
  "position": "above_lowest",
  "comparableCount": 2,
  "changesSinceLastRun": 1,
  "suggestedPrice": 116.96,
  "decision": "review",
  "reason": "undercut_percent, lowest comparable: Shop B at 119 EUR: -12.99 (-10%); guards: max_change.",
  "guards": ["max_change"],
  "shopUpdate": { "sku": "RUNNER-42", "currentPrice": 129.95, "newPrice": 116.96, "currency": "EUR", "status": "needs_approval" },
  "shopResult": null,
  "chargedPages": 2,
  "competitors": [
    {
      "competitorName": "Shop B",
      "competitorUrl": "https://shop-b.example/product/trail-runner/",
      "competitorStatus": "ok",
      "competitorPrice": 119,
      "competitorCurrency": "EUR",
      "competitorAvailability": "InStock",
      "competitorSource": "json-ld",
      "competitorPreviousPrice": 124,
      "competitorPriceChange": -5,
      "competitorChangeType": "price_drop",
      "competitorGap": 10.95,
      "competitorUsed": true
    }
  ],
  "checkedAt": "2026-10-02T06:00:00.000Z"
}

decision is one of monitor, review (suggest mode), apply (automatic, not pushed), pushed, push_failed, hold (already at the rule price), no_data (no comparable competitor price) or no_your_price. competitorStatus is ok, no_price, blocked, robots_disallowed, not_found, http_error or fetch_error. The run's SUMMARY record (key-value store) has counters, charges and warnings.

Shop push (optional)

Only in Automatic mode with Write new prices to my shop on, and only when a rule changes the price:

• Shopify: Admin GraphQL API (productVariantsBulkUpdate) on your-store.myshopify.com with a custom-app token (write_products). Each product needs its variantId. The token is only ever sent to a *.myshopify.com domain.
• WooCommerce: REST API PUT /wp-json/wc/v3/products/{id} (or /variations/{id}) setting regular_price, over HTTPS with a Read/Write consumer key and secret. (If a product has an active sale_price, that one stays visible in your shop.)
• Webhook: a JSON POST per change (sku, variantId, shopProductId, oldPrice, newPrice, currency, reason, runId), optionally signed with X-CPM-Signature: sha256=<HMAC-SHA256 of the body>. Use it for UNAS, Shoprenter, OpenCart, Lightspeed, Magento, a Google Sheet, Slack, etc. via Zapier / Make / n8n.

Start with Suggest mode for a few days, check the suggestions, then switch on Automatic.

Pricing

Pay per event, no subscription:

Event	Price	When
product-checked	$0.004 ($4 per 1,000)	a competitor (or your own) product page where a price was found
price-pushed	$0.01	a price your shop / webhook accepted

Blocked, robots-disallowed and unpriced pages, summaries, suggestions and failed pushes are free. Example: 200 products × 3 competitors, checked daily = 18,000 pages / month ≈ $72 / month; weekly ≈ $10. Set Maximum cost per run in the run options: the Actor stops cleanly when it is reached (it reserves the budget before fetching a page, so it never goes over).

Limitations

• No browser: the Actor reads the HTML / JSON a shop sends. Prices that only appear after JavaScript runs (rare for shops; most server-render JSON-LD or meta tags) are reported as no_price (free). A headless Chrome fallback would need a ~1.5 GB image, 1-2 GB of memory and ~10× the compute per page, so it is deliberately left out.
• Bot protection: Cloudflare / DataDome / PerimeterX challenges and captchas are never bypassed; Amazon, bol.com, Zalando and other large marketplaces typically block automated requests and will show blocked.
• Product matching: you provide the competitor URLs. markets discovery is a beta helper that only keeps pages matching the EAN or most words of the name; shops whose robots.txt disallows search (e.g. all Shopify shops) are skipped.
• Variants: the price of the variant in the URL (?variant=) or the first in-stock variant is used.
• Currencies: offers in another currency are reported but not converted or used for suggestions. Shops with geo-pricing show the price for the Actor's server location (use the market URL, e.g. /en-nl/products/...).
• Prices: the advertised product price, without shipping, coupons or loyalty discounts. VAT handling follows what the shop displays.
• History is one record per store name; give parallel schedules different historyStoreNames.

FAQ

Is it legal to monitor competitor prices? Reading publicly displayed prices is common practice; the Actor respects robots.txt, identifies itself and does not bypass access controls. Check the terms of the sites you monitor.

How often should I run it? Daily is typical; hourly is possible for small catalogs (mind the cost).

Can it run without competitor URLs? Use markets (beta) with competitor home pages, or build URL lists with a search / sitemap scraper first.

Does it change my prices without asking? Never by default. Prices are only written in Automatic mode with the push switch on, within your floor, margin and max-change guards.