How to Track Amazon Product Prices and Stock Status

Why Track Amazon Prices?

Amazon changes product prices constantly. A single product can see dozens of price adjustments in a week — driven by competitor pricing, inventory levels, demand signals, time of day, and Amazon's own algorithmic repricing. The same item might cost $49.99 in the morning and $42.17 by evening.

For anyone making purchasing or selling decisions — eCommerce operators benchmarking against Amazon, resellers watching for margin opportunities, procurement teams timing bulk purchases, or consumers waiting for the right price — knowing when prices change and what stock looks like across variations is directly actionable intelligence.

The challenge is that Amazon is one of the hardest eCommerce sites to scrape reliably.

Why Amazon Is Difficult to Scrape

Amazon invests heavily in anti-bot protections. Simple HTTP requests with requests or curl will quickly return CAPTCHAs, throttled responses, or outright blocks. Even rotating user agents and adding delays between requests only gets you so far.

JavaScript-rendered content. Many product page elements — including variation-specific pricing, stock badges, and Buy Box seller information — are loaded dynamically. A static HTML fetch often misses the data you actually need.

Variation complexity. An Amazon product listing for a t-shirt might have 8 colors and 6 sizes — 48 combinations, each with its own price, stock status, and potentially a different seller. Extracting that full variation matrix from the page DOM is significantly harder than grabbing the headline price.

Geolocation and currency. Amazon serves different prices and availability based on the visitor's location. Tracking a product's price in the US market is a different request than tracking it in Germany or Japan.

Frequent layout changes. Amazon constantly A/B tests page layouts. Selectors that work today may break tomorrow without warning. Any custom scraper targeting Amazon requires ongoing maintenance.

Browser Extensions and Price Trackers

Tools like CamelCamelCamel, Keepa, and Honey offer consumer-facing Amazon price tracking. They maintain historical price charts, send price drop alerts, and integrate directly with your browser.

CamelCamelCamel tracks price history across Amazon's own sellers and third-party marketplace sellers. You can set a target price and receive email alerts when it drops. It's free and covers Amazon's major markets.

Keepa provides detailed price history charts, stock level tracking, and a browser extension that embeds price graphs directly on Amazon product pages. Keepa's data subscription (starting at €19/month) unlocks API access for programmatic queries.

These tools are excellent for individual product tracking and consumer use cases. But they have clear limitations for business applications:

• No custom workflow integration. You get their dashboard and their alert format. Feeding Amazon price data into your own pricing engine, spreadsheet, or database requires manual export or screen scraping their interface.
• Limited variation coverage. Most consumer trackers follow the main listing price. If you need to know that size Large in Blue is out of stock while Medium in Black just dropped 15%, they typically won't surface that.
• No cross-platform view. These tools track Amazon only. If you're monitoring the same product across Amazon, Walmart, and the brand's own DTC site, you need separate tools for each — and no unified data model.

Building a DIY Amazon Scraper

A common next step is building your own scraper. With a headless browser like Playwright you can render JavaScript, select a product variation, and extract the resulting price.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://www.amazon.com/dp/B09V3KXJPB",
               wait_until="networkidle")

    title = page.inner_text("#productTitle")
    price_whole = page.inner_text(".a-price-whole")
    price_fraction = page.inner_text(".a-price-fraction")
    availability = page.inner_text("#availability span")

    print(f"{title.strip()}: ${price_whole}{price_fraction}")
    print(f"Stock: {availability.strip()}")

    browser.close()

This works — until it doesn't. Amazon detects headless browsers aggressively. Within a handful of requests you'll hit CAPTCHAs, bot detection pages, or IP blocks. Scaling this beyond a few manual lookups requires:

• Residential proxy rotation to avoid IP-based blocking — services like Bright Data or Oxylabs provide rotating residential IPs
• Browser fingerprint spoofing to pass bot detection
• CAPTCHA solving services like 2captcha or Anti-Captcha for when detection slips through
• Retry logic with exponential backoff
• Selector maintenance for when Amazon changes its page structure

That's a significant infrastructure investment for what started as "check a price."

The Variation Problem

The hardest part of Amazon price tracking isn't getting the headline price — it's getting the full picture across product variations.

Consider a product with 5 colors and 4 sizes. The Amazon product page shows one price at a time, for the currently selected combination. To capture pricing and stock for all 20 combinations, a scraper needs to:

1. Identify all variation dimensions (color, size, style, etc.)
2. Programmatically select each combination
3. Wait for the page to update with the new price and stock status
4. Extract and record the data for that specific combination
5. Repeat for every combination

Some variations have different ASINs and are essentially separate product pages linked through a parent. Others share an ASIN but render different prices based on the selected options. Handling both patterns correctly — and identifying which variations are in stock, which are out of stock, and which are fulfilled by Amazon vs. third-party sellers — is where most DIY scrapers fall apart.

Using the felid.io API for Amazon Tracking

felid.io handles the hard parts — anti-bot bypass, JavaScript rendering, variation extraction, and structured normalization — and returns clean, consistent product data from a single API call.

Scraping an Amazon Product

curl -X POST https://felid.io/v1/products/scrape \
  -H "Authorization: ApiKey YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.amazon.com/dp/B09V3KXJPB",
    "country": "us"
  }'

The response is a normalized product model — the same structure whether you're scraping Amazon, Walmart, Shopify, or any other eCommerce platform:

{
  "type": "VARIABLE",
  "name": "Outdoor Hiking Backpack",
  "brand": "TrailPeak",
  "currency": "USD",
  "priceMin": 39.99,
  "priceMax": 54.99,
  "isOnSale": true,
  "variations": [
    {
      "name": "Color: Black - Size: 40L",
      "priceNow": 39.99,
      "priceBase": 49.99,
      "availability": "IN_STOCK",
      "sku": "B09V3KXJPB-BLK-40"
    },
    {
      "name": "Color: Green - Size: 40L",
      "priceNow": 42.99,
      "priceBase": 49.99,
      "availability": "IN_STOCK",
      "sku": "B09V3KXJPB-GRN-40"
    },
    {
      "name": "Color: Black - Size: 55L",
      "priceNow": 54.99,
      "priceBase": 64.99,
      "availability": "OUT_OF_STOCK",
      "sku": "B09V3KXJPB-BLK-55"
    }
  ],
  "category": ["Sports & Outdoors", "Hiking Backpacks"],
  "image": ["https://m.media-amazon.com/images/I/..."]
}

Every variation's price and stock status is extracted in a single request. No headless browser to manage, no selectors to maintain, no proxy infrastructure to run.

The country parameter controls which Amazon marketplace you're targeting — us for amazon.com, de for amazon.de, jp for amazon.co.jp, and so on. Same API call, same response structure, different market.

Setting Up Continuous Monitoring

One-off scrapes are useful, but price tracking becomes valuable when it's continuous. The felid.io monitoring API lets you register a product URL for scheduled tracking with automatic change detection.

curl -X POST https://felid.io/v1/products/monitors \
  -H "Authorization: ApiKey YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.amazon.com/dp/B09V3KXJPB",
    "country": "us",
    "interval": "EVERY_6_HOURS"
  }'

Available intervals are HOURLY, EVERY_6_HOURS, DAILY, and WEEKLY. The monitor validates the URL with an initial scrape — if the product can't be scraped successfully, the monitor won't be created, so you know immediately if something is wrong.

Once active, the monitor checks the product on schedule and records changes. You can query the change history to see exactly what changed and when:

curl https://felid.io/v1/products/monitors/{monitor_id}/changes \
  -H "Authorization: ApiKey YOUR_API_KEY"

{
  "changes": [
    {
      "fieldChanges": [
        {
          "field": "priceNow",
          "previousValue": 49.99,
          "newValue": 39.99,
          "type": "SCALAR"
        }
      ],
      "structuralChanges": [
        {
          "type": "VARIATION_REMOVED",
          "sku": "B09V3KXJPB-BLK-55",
          "details": {}
        }
      ],
      "detectedAt": "2026-03-21T14:30:00Z"
    }
  ]
}

The change detection works at both the field level (price changed from X to Y) and the structural level (a variation was added or removed). This means you can detect not just price drops, but also when a previously out-of-stock variation comes back, or when Amazon removes a color option entirely.

Triggering Manual Checks

If you need fresher data than the scheduled interval provides — for example, before making a purchasing decision — you can trigger a manual check:

curl -X POST https://felid.io/v1/products/monitors/{monitor_id}/check \
  -H "Authorization: ApiKey YOUR_API_KEY"

The check runs asynchronously and deduplicates within a short cooldown window, so repeated calls won't waste resources.

Building an Amazon Price Tracking Pipeline

With felid.io handling the scraping and monitoring infrastructure, you can focus on what to do with the data.

Scheduled monitoring + webhook alerts. Set up monitors for competitor ASINs and connect the change events to your alerting system. When a competitor drops their price on a key product, your team knows within hours — not days.

Cross-marketplace comparison. The same API call works for Amazon US, Amazon DE, Walmart, Target, and any other supported eCommerce site. Track the same product across multiple retailers with one unified data model, making price comparison straightforward.

Historical price analysis. The change history endpoint gives you a time series of price and stock changes. Feed this into your analytics stack to identify pricing patterns — does this product always drop before Prime Day? Does stock run low every third week?

Automation platforms. Tools like n8n can orchestrate the full pipeline: poll monitor changes on a schedule, filter for significant price drops, update a Google Sheet, and send a Slack notification — all without writing custom infrastructure code.

The Right Level of Abstraction

Amazon price tracking is a problem with multiple valid solutions depending on your scale and requirements.

Browser extensions like CamelCamelCamel and Keepa are the right choice for individual consumers watching a handful of products. They're free or cheap, require no technical setup, and deliver price alerts effectively.

DIY scrapers make sense when you have a very specific extraction need, control the infrastructure, and are prepared to maintain the scraper as Amazon's defenses and page layout evolve.

felid.io fits the space in between — when you need structured, variation-level Amazon product data integrated into your own systems, but don't want to build and maintain scraping infrastructure. The API handles anti-bot bypass, JavaScript rendering, variation extraction, and change detection. You get clean product data and a monitoring pipeline you can plug into any workflow.

The hard part of Amazon price tracking was never making the HTTP request. It's getting reliable, structured, variation-level data from a site that actively resists being scraped — and keeping that working over time. That's the infrastructure felid.io provides.