Monitor Amazon Competitor Pricing and Ratings (2026)

Thirdwatch's Amazon Scraper makes ASIN-level competitor monitoring a structured workflow on a pay-per-record basis — daily snapshots of price, rating, reviews_count, BSR, in_stock, Buy Box seller. Built for FBA operators, marketplace-tools SaaS builders, brand-protection teams, and pricing-strategy functions that need real-time Amazon competitive intelligence.

Why monitor Amazon competitor pricing and ratings

Amazon competitive intelligence is real-time. According to Amazon's 2024 Marketplace report, prices on competitive ASINs change 5-15 times per day driven by pricing engines and demand-elastic algorithms. For FBA operators, brand-protection teams, and marketplace-tools SaaS, daily ASIN-level monitoring is the difference between catching competitor moves same-day vs days later.

The job-to-be-done is structured. An FBA operator monitors 200 competitor ASINs daily for price-drop response. A marketplace-tools SaaS surfaces ASIN-level competitive signals to operator users. A brand-protection team watches counterfeit-listing pricing for IP-enforcement triggers. A pricing-strategy function builds elasticity models from per-ASIN price-rating-volume time series. All reduce to ASIN watchlist + daily snapshot + delta detection + alert routing.

How does this compare to the alternatives?

Three options for ASIN-level competitive intelligence:

Keepa is the canonical price-history tool. Helium 10 bundles broader analytics. The Amazon Scraper actor page gives you raw daily snapshots at the lowest unit cost.

How to monitor competitor ASINs in 4 steps

Step 1: How do I authenticate against Apify?

Sign in at apify.com (free tier, no credit card), open Settings → Integrations, and copy your personal API token:

export APIFY_TOKEN="apify_api_xxxxxxxxxxxxxxxx"

Step 2: How do I pull a competitor ASIN watchlist daily?

Pass ASIN list directly.

import os, requests, datetime, json, pathlib

ACTOR = "thirdwatch~amazon-scraper"
TOKEN = os.environ["APIFY_TOKEN"]

# Watchlist of competitor ASINs in your category
ASINS = ["B07ABC1234", "B08DEF5678", "B09GHI9012",
         "B07JKL3456", "B08MNO7890", "B09PQR1234",
         "B07STU5678", "B08VWX9012"]

resp = requests.post(
    f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={"asins": ASINS, "country": "us"},
    timeout=900,
)
records = resp.json()
ts = datetime.datetime.utcnow().strftime("%Y%m%d")
pathlib.Path(f"snapshots/amazon-asins-{ts}.json").write_text(json.dumps(records))
print(f"{ts}: {len(records)} ASINs snapshotted")

200 ASINs daily — well within budget for a daily refresh.

Step 3: How do I detect price drops and rating drift?

Compare daily snapshots and surface deltas.

import pandas as pd, glob

snapshots = sorted(glob.glob("snapshots/amazon-asins-*.json"))
dfs = []
for s in snapshots:
    df = pd.DataFrame(json.loads(open(s).read()))
    df["snapshot_date"] = pd.to_datetime(s.split("-")[-1].split(".")[0])
    dfs.append(df)

all_df = pd.concat(dfs, ignore_index=True)
all_df["price"] = pd.to_numeric(all_df.price.astype(str).str.replace(r"[$,]", "", regex=True), errors="coerce")

today = all_df[all_df.snapshot_date == all_df.snapshot_date.max()].set_index("asin")
yesterday = all_df[all_df.snapshot_date == sorted(all_df.snapshot_date.unique())[-2]].set_index("asin")

combined = today.merge(yesterday, left_index=True, right_index=True, suffixes=("", "_prev"))
combined["price_delta_pct"] = (combined.price - combined.price_prev) / combined.price_prev
combined["rating_delta"] = combined.rating - combined.rating_prev

drops = combined[(combined.price_delta_pct <= -0.10) & combined.in_stock].sort_values("price_delta_pct")
rating_drops = combined[combined.rating_delta <= -0.3]
print(f"{len(drops)} price drops, {len(rating_drops)} rating drops")

Combine price + in_stock filters to avoid alerting on out-of-stock false signals.

Step 4: How do I forward alerts to Slack?

Persist alerted (asin, date) tuples and forward only new alerts.

import requests as r

snapshot = pathlib.Path("amazon-alerts-seen.json")
seen = set(tuple(x) for x in json.loads(snapshot.read_text())) if snapshot.exists() else set()

alerts = []
for _, d in drops.iterrows():
    key = (d.name, str(d.snapshot_date))
    if key in seen:
        continue
    alerts.append((d.name, d.title, d.price_prev, d.price, d.price_delta_pct))
    seen.add(key)

for asin, title, prev_price, price, delta in alerts:
    r.post("https://hooks.slack.com/services/.../...",
           json={"text": (f":chart_with_downwards_trend: *{asin}* {title[:80]}\n"
                          f"${prev_price:.2f} → ${price:.2f} ({delta*100:+.1f}%)")},
           timeout=10)

snapshot.write_text(json.dumps([list(x) for x in seen]))
print(f"{len(alerts)} new price-drop alerts forwarded")

Schedule daily; the loop runs unattended.

Sample output

A single competitor ASIN snapshot looks like this. Five rows weigh ~6 KB.

{
  "asin": "B07ABC1234",
  "title": "Premium Silicone Baking Mat - 16x12 inch Set of 2",
  "price": "$14.99",
  "rating": 4.6,
  "reviews_count": 12450,
  "bsr": 234,
  "buy_box_seller": "Acme Kitchen Co",
  "category": "Kitchen & Dining > Bakeware > Baking Mats",
  "image_url": "https://m.media-amazon.com/images/I/...",
  "in_stock": true,
  "prime_eligible": true,
  "monthly_sold": "10K+ bought in past month"
}

asin is the canonical key. price, rating, reviews_count, and bsr are the four monitored signals. buy_box_seller enables Buy Box rotation tracking. in_stock: true/false filters out spurious zero-price events.

Common pitfalls

Three things go wrong in ASIN-monitoring pipelines. Out-of-stock false alerts — when a product goes out of stock, Amazon sometimes shows last-known price or no price; combine in_stock: true filter with price-delta detection to suppress these. Rating-bombing detection — coordinated negative-review attacks distort rating signal; cross-check rating drops against new-reviews-this-week velocity to distinguish genuine quality issues from organized attacks. Multi-variant ASIN drift — apparel and consumer-electronics products often have parent + child ASINs; monitor parent ASIN for headline-price tracking and child ASINs only when variant-specific competition matters.

Thirdwatch's actor handles proxy rotation so you can focus on the data. Pair Amazon with Flipkart Scraper for India-marketplace competitive intelligence. A fourth subtle issue worth flagging: Amazon's price-update propagation is regional — a price set in the US store doesn't automatically flow to the UK or DE store; for multi-region competitive monitoring, run separate ASIN watchlists per Amazon TLD (amazon.com, amazon.co.uk, amazon.de) since the same ASIN often has materially different price/rating/availability across regions. A fifth pattern unique to Amazon competitor work: certain top-selling categories use coupon-stacking heavily (display price stays stable while applied-coupon discount changes daily) — for accurate effective-price tracking, supplement raw price extraction with coupon-text parsing because two products at "$14.99" may have effective prices of $11.99 and $13.49 once coupons apply. A sixth and final pitfall: Buy Box ownership rotates 5-20 times per day on highly-competitive ASINs — daily snapshots show the seller at scrape time, not the rotation pattern; for true Buy Box dynamics analysis, snapshot at multiple times per day or rely on Keepa's higher-frequency feed for the top-priority ASINs. A seventh and final pattern worth flagging for production teams: data-pipeline cost optimization. The actor's pricing scales linearly with record volume, so for high-cadence operations (hourly polling on large watchlists), the dominant cost driver is the size of the watchlist rather than the per-record fee. For cost-disciplined teams, tier the watchlist (Tier 1 hourly, Tier 2 daily, Tier 3 weekly) rather than running everything at the highest cadence — typical 60-80% cost reduction with minimal signal loss. Combine tiered cadence with explicit dedup keys and incremental snapshot diffing to keep storage and downstream-compute proportional to new signal rather than total watchlist size. This is the difference between a lean and a bloated research pipeline for the same actionable output. An eighth subtle issue worth flagging: snapshot-storage strategy materially affects long-term pipeline economics. Raw JSON snapshots compressed with gzip typically run 4-8x smaller than uncompressed; for multi-year retention, always compress at write-time. For high-frequency snapshots, partition storage by date prefix (snapshots/YYYY/MM/DD/) to enable fast date-range queries and incremental processing rather than full-scan re-aggregation. Most production pipelines keep 90 days of raw snapshots at full fidelity + 12 months of derived per-record aggregates + indefinite retention of derived metric time-series — three retention tiers managed separately.

Related use cases

• Scrape Amazon products for price monitoring
• Track Amazon bestsellers by category
• Build an Amazon product research tool
• The complete guide to scraping ecommerce
• All Thirdwatch use-case guides