Monitor Competitor Pricing With the Price Tracker (2026)

Thirdwatch's Price Tracker turns competitor price monitoring into a structured daily workflow. Track competitor product pages on Amazon, Shopify stores, or any site with structured pricing data — get price, availability, brand, and rating in a single API call. Built for founders making pricing decisions, brand managers defending market position, and category leads who need to know when a competitor moves before their customers notice.

Why monitor competitor pricing

Pricing is the fastest lever in e-commerce. According to Simon-Kucher's 2025 Global Pricing Study, a 1% improvement in pricing realization drives an average 8.7% increase in operating profit — more than any equivalent improvement in volume or cost. But pricing realization depends on knowing where you stand relative to competitors in real time, not in quarterly reviews.

The scenario is familiar to every founder. You price your flagship product at a 15% premium over your closest competitor. One morning a customer emails asking for a price match — the competitor dropped 20% overnight for a flash sale. Your team does not notice for three days. By then your conversion rate has already taken the hit. The core problem is not that competitors change prices — it is that the change reaches your customers before it reaches you.

Automated competitor price monitoring closes this gap. The Price Tracker checks your competitor watchlist daily, flags changes above your threshold, and gives your team a 24-hour response window. The output is structured — productName, price, currency, availability, platform — which means the data feeds directly into pricing rules, Slack alerts, or spreadsheet models without manual cleanup.

How does this compare to the alternatives?

Three paths for competitor price intelligence:

Manual checks work for 5-10 products but break at 30+. Enterprise SaaS bundles analytics on top of data collection — worth it for large catalog retailers, overkill for DTC founders watching 20-50 competitor SKUs. The Price Tracker actor page gives you the data collection layer at pay-per-result pricing, and this guide shows you how to build the alerting layer on top.

How to monitor competitor pricing in 5 steps

Step 1: How do I build a competitor watchlist?

Identify the 10-30 product URLs that directly compete with your top sellers. Include the exact product page URL, not a search or category page.

# competitors.py
COMPETITORS = {
    "wireless_earbuds": {
        "our_price": 79.99,
        "competitor_urls": [
            "https://www.amazon.com/dp/B09V3KXJPB",   # Apple AirPods Pro
            "https://www.amazon.com/dp/B0C8X3G9M7",   # Samsung Galaxy Buds
            "https://www.amazon.com/dp/B0BT35LT8S",   # Bose QuietComfort Earbuds
        ],
    },
    "running_shoes": {
        "our_price": 130.00,
        "competitor_urls": [
            "https://www.allbirds.com/products/mens-tree-runners",
            "https://www.on-running.com/en-us/products/cloudmonster",
            "https://www.nike.com/t/pegasus-41-mens-road-running-shoes",
        ],
    },
    "water_bottle": {
        "our_price": 35.00,
        "competitor_urls": [
            "https://www.stanley1913.com/products/quencher-h2-0-flowstate-tumbler-40-oz",
            "https://www.hydroflask.com/32-oz-wide-mouth",
            "https://www.yeti.com/drinkware/bottles/rambler-26oz-bottle.html",
        ],
    },
}

ALL_URLS = [url for cat in COMPETITORS.values() for url in cat["competitor_urls"]]

Step 2: How do I authenticate and run the tracker?

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"
pip install apify-client

# monitor.py
import os
from apify_client import ApifyClient
from competitors import COMPETITORS, ALL_URLS

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("thirdwatch/price-tracker").call(run_input={
    "urls": ALL_URLS,
    "maxRetries": 3,
    "proxyCountry": "US",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
price_map = {item["url"]: item for item in items if item.get("success")}
print(f"Tracked {len(price_map)} competitor products successfully")
# Note: the actor returns camelCase fields (productName, originalPrice, etc.)

Step 3: How do I compare competitor prices against mine?

Map each competitor result back to your product categories and compute the price gap.

# compare.py
from competitors import COMPETITORS

for category, data in COMPETITORS.items():
    our_price = data["our_price"]
    print(f"\n--- {category.upper()} (our price: ${our_price}) ---")

    for url in data["competitor_urls"]:
        if url not in price_map:
            print(f"  MISSING: {url}")
            continue

        comp = price_map[url]
        gap = ((our_price - comp["price"]) / comp["price"] * 100)
        position = "premium" if gap > 0 else "undercut"
        availability = comp["availability"]

        print(f"  {comp['productName']}: {comp['currency']} {comp['price']} "
              f"({position} by {abs(gap):.1f}%) — {availability}")

This gives you a real-time competitive position map. A "premium by 25%" reading on your flagship category means you have pricing room. An "undercut by 10%" means a competitor moved and you are now the expensive option.

Step 4: How do I detect and alert on price changes?

Store daily snapshots and compare against the previous day to catch movements.

# alert.py
import json, pathlib, datetime, requests

snapshot_dir = pathlib.Path("competitor_snapshots")
snapshot_dir.mkdir(exist_ok=True)

today = datetime.date.today().isoformat()
today_file = snapshot_dir / f"prices-{today}.json"
today_file.write_text(json.dumps(price_map, default=str))

# Load yesterday's snapshot
yesterday = (datetime.date.today() - datetime.timedelta(days=1)).isoformat()
yesterday_file = snapshot_dir / f"prices-{yesterday}.json"

if yesterday_file.exists():
    prev_map = json.loads(yesterday_file.read_text())

    for url, current in price_map.items():
        if url not in prev_map:
            continue
        prev_price = prev_map[url]["price"]
        curr_price = current["price"]

        if prev_price and curr_price:
            pct = ((curr_price - prev_price) / prev_price) * 100
            if abs(pct) >= 5.0:
                direction = "DROPPED" if pct < 0 else "INCREASED"
                msg = (f"*{current['productName']}* {direction} {abs(pct):.1f}%\n"
                       f"{current['currency']} {prev_price} -> {curr_price}\n"
                       f"Platform: {current['platform']}\n{url}")
                requests.post("https://hooks.slack.com/services/.../...",
                              json={"text": msg}, timeout=10)
                print(f"ALERT: {msg}")

A 5% threshold catches meaningful competitor moves without alert fatigue from minor fluctuations. Adjust per category — commodity products warrant 2-3%, differentiated brands can tolerate 8-10%.

Step 5: How do I build a weekly competitor pricing report?

Aggregate the week's snapshots into a summary for your pricing review meeting.

# weekly_report.py
import json, pathlib, datetime, pandas as pd

snapshot_dir = pathlib.Path("competitor_snapshots")
records = []

for i in range(7):
    date = (datetime.date.today() - datetime.timedelta(days=i)).isoformat()
    fpath = snapshot_dir / f"prices-{date}.json"
    if fpath.exists():
        data = json.loads(fpath.read_text())
        for url, item in data.items():
            records.append({"date": date, "url": url, **item})

df = pd.DataFrame(records)
if len(df) > 0:
    summary = df.groupby("url").agg(
        product=("productName", "last"),
        min_price=("price", "min"),
        max_price=("price", "max"),
        current_price=("price", "last"),
        availability_changes=("availability", "nunique"),
    ).reset_index()

    summary["weekly_range_pct"] = (
        (summary["max_price"] - summary["min_price"]) / summary["min_price"] * 100
    ).round(1)

    print("Weekly Competitor Pricing Report")
    print(summary.sort_values("weekly_range_pct", ascending=False).to_string(index=False))

Products with a wide weekly range (10%+) are actively being promotional-priced by competitors. Products with zero range have stable pricing you can plan around.

Sample output

A competitor price check returns structured records like these. Two records weigh approximately 700 bytes.

[
  {
    "url": "https://www.amazon.com/dp/B09V3KXJPB",
    "productName": "Apple AirPods Pro (2nd Generation)",
    "price": 189.99,
    "originalPrice": 249.99,
    "currency": "USD",
    "discount": "24%",
    "availability": "In Stock",
    "brand": "Apple",
    "rating": 4.7,
    "reviewCount": 84200,
    "imageUrl": "https://m.media-amazon.com/images/I/61SUj2aKoEL._AC_SL1500_.jpg",
    "platform": "amazon",
    "scrapedAt": "2026-05-26T07:00:00.000Z",
    "success": true
  },
  {
    "url": "https://www.on-running.com/en-us/products/cloudmonster",
    "productName": "Cloudmonster - Road Running Shoe",
    "price": 169.99,
    "originalPrice": null,
    "currency": "USD",
    "discount": null,
    "availability": "In Stock",
    "brand": "On",
    "rating": 4.5,
    "reviewCount": 1230,
    "imageUrl": "https://www.on-running.com/media/cloudmonster.jpg",
    "platform": "generic",
    "scrapedAt": "2026-05-26T07:00:00.000Z",
    "success": true
  },
  {
    "url": "https://www.stanley1913.com/products/quencher-h2-0-flowstate-tumbler-40-oz",
    "productName": "Quencher H2.0 FlowState Tumbler 40 oz",
    "price": 45.00,
    "originalPrice": null,
    "currency": "USD",
    "discount": null,
    "availability": "In Stock",
    "brand": "Stanley",
    "rating": 4.8,
    "reviewCount": 52100,
    "imageUrl": "https://www.stanley1913.com/cdn/quencher.jpg",
    "platform": "shopify",
    "scrapedAt": "2026-05-26T07:00:00.000Z",
    "success": true
  }
]

The brand and rating fields add context beyond price. A competitor with a higher rating at a lower price is a bigger threat than one with a lower rating at a lower price — rating acts as a quality proxy that influences the effective price gap your customers perceive.

Common pitfalls

Four mistakes founders make with competitor price monitoring. Tracking too many SKUs too early — founders add 200 competitor URLs on day one, get overwhelmed by alerts, and stop checking. Start with 10-20 products that directly compete with your top 5 revenue SKUs. Expand only after your response workflow is proven. Reacting to every price drop — a competitor drops 15% for a 48-hour flash sale. You match. They return to normal. You are now 15% cheaper than needed. Use a 3-day confirmation window before matching long-term price changes. Flash sales revert; structural repricing does not. Ignoring availability context — a competitor going out of stock is as actionable as a price drop. When a competitor's availability flips to "Out of Stock", you can increase ad spend on that product knowing shoppers are looking for alternatives.

A fourth trap specific to DTC founders: comparing your Shopify store price against Amazon prices without accounting for channel differences. Amazon prices include marketplace fees baked into the seller's margin calculation, while your Shopify price is direct. A competitor at the same nominal price on Amazon is actually operating at lower margin. Use the platform field to segment your competitive analysis — Amazon-vs-Amazon and DTC-vs-DTC comparisons are more actionable than cross-channel ones. A fifth pattern: seasonal price cycles create false urgency. If a competitor drops 20% every November for Black Friday, that is not a surprise — it is a pattern. After accumulating 60-90 days of data, build a seasonal baseline so your alerts distinguish genuine competitive moves from predictable promotional cycles.

Related use cases

• Track product prices across e-commerce sites
• Build a price monitoring dashboard for e-commerce
• Automate price drop alerts for any product
• Monitor eBay India prices for competitive intel
• The complete guide to scraping e-commerce data
• All Thirdwatch use-case guides