How to Build an Amazon Price Tracker That Auto-Buys (2026)

Keepa, CamelCamelCamel, and HARPA will tell you when an Amazon price drops. They will not place the order. If you want a tool that tracks Amazon prices and auto-buys when they drop, you need an observer plus an execution API. Trackers watch the listing. Zinc's Create Order endpoint buys it when the live total is still under your max_price.

• What Amazon price trackers actually do
• Keepa, HARPA, CamelCamelCamel, Alexa, and ShopSavvy
• Trackers alert. They don't buy.
• Architecture: poll, threshold, Zinc order
• A short Python and cron sketch
• Mistakes that waste the drop
• FAQ

What Amazon price trackers actually do

An Amazon price tracker records a listing's price over time, draws a chart, and emails you when the number crosses a target. HARPA AI's 2026 roundup puts Keepa first for depth and CamelCamelCamel first among free tools. That is the right stack if you still want a human to open the product page.

The loop stops at the alert:

watch ASIN -> store price -> if price <= target -> notify

Nothing in that loop talks to checkout. Amazon prices move often. By the time you see the email, the Buy Box can be gone, a third-party seller can own the offer, or tax and shipping can push the total over what you meant to spend.

If you are only researching "is this a real discount," a tracker is enough. If the requirement is "buy it while it is still at that price," you need checkout. Scraping the Amazon cart yourself is a poor substitute. Layout changes, CAPTCHAs, and session rules break those scripts. See web scraping vs ecommerce API for why observation and buying are different jobs.

Keepa, HARPA, CamelCamelCamel, Alexa, and ShopSavvy

Name the tools you will actually find, then be precise about what they ship.

Those HARPA and Keepa figures are what the vendor pages publish. Confirm current install counts and marketplace coverage on the listing before you depend on them.

None of these replace Amazon's official APIs. PA-API is affiliate search. SP-API is seller ops. Neither places a shopper order for your software.

Trackers alert. They don't buy

Deal forums still treat "auto buy" as a browser macro or an Alexa skill. That works for one person, one Amazon account, one shipping address.

A product, a procurement bot, or a replenishment job needs something else:

• A threshold you enforce at order time, not the price you saw six hours ago
• An idempotency key so a retried cron does not buy twice
• A shipping address your system already stores
• Webhooks when the retailer accepts, ships, or fails the order

Keepa can tell you the Amazon price hit $79. Zinc can refuse the order if the cart, after tax and shipping, would exceed max_price: 7900. That is the difference between an alert and an order.

Amazon-only auto-buy also misses a cheaper in-stock offer at Walmart or Target. If your rule is "buy this SKU under $X," search more than one retailer. Zinc covers 50+ US retailers. Keepa does not.

Architecture: poll, threshold, Zinc order

Keep the tracker. Add a buyer.

1. Store the watchlist. Product URL or ASIN, target price in cents, shipping address, and a stable idempotency_key per watch (for example watch_B07JGBW826_2026-08).
2. Poll on a schedule. Cron, GitHub Actions, or a worker every 15 to 60 minutes is enough for most drops. Do not scrape Amazon HTML. Use a data API you already pay for (Keepa, Bright Data, ShopSavvy) or GET /products/{asin}?retailer=amazon for the live offer you are about to buy.
3. Compare apples to apples. Trackers often quote the list price. Your threshold should be the all-in cap you will send as max_price.
4. Place the order once. Call Zinc Create Order. If the retailer total is over the cap, the order fails cleanly instead of charging extra.
5. Listen after checkout. order.placed, order.failed, order.tracking_received, order.delivered. Deduplicate webhooks. See webhooks and shipment tracking.

Start in test mode. A bad selector or a stale Keepa tick should not hit a live card.

You can keep Keepa as the historian (years of charts, Buy Box, rank) and only call Zinc when the rule fires. Zinc is not a Keepa replacement. It does not warehouse years of Amazon price ticks.

A short Python and cron sketch

Bright Data already published a scraper tutorial: fetch the page, parse a price, write CSV, schedule with schedule.every(12).hours. Those scripts observe. The sketch below buys.

import os, json, urllib.error, urllib.request

ZINC = "https://api.zinc.com"
KEY = os.environ["ZINC_API_KEY"]
WATCH = {
    "url": "https://www.amazon.com/dp/B07JGBW826",
    "product_id": "B07JGBW826",
    "max_price": 7900,  # cents, all-in cap
    "idempotency_key": "watch_B07JGBW826_aug31",
}

def zinc(path, payload=None, method="GET"):
    req = urllib.request.Request(
        ZINC + path,
        data=None if payload is None else json.dumps(payload).encode(),
        headers={
            "Authorization": f"Bearer {KEY}",
            "Content-Type": "application/json",
        },
        method=method,
    )
    try:
        with urllib.request.urlopen(req) as res:
            return json.load(res)
    except urllib.error.HTTPError as e:
        body = json.loads(e.read().decode())
        # Same key again: the original order exists. Treat as success.
        if body.get("code") == "already_exists":
            return body
        raise

details = zinc("/products/" + WATCH["product_id"] + "?retailer=amazon")
# If you already poll Keepa, skip details and use that price.
if details.get("price", 10**9) > WATCH["max_price"]:
    raise SystemExit("still above target")

zinc("/orders", {
    "idempotency_key": WATCH["idempotency_key"],
    "products": [{"url": WATCH["url"], "quantity": 1}],
    "shipping_address": {
        "first_name": "Jordan",
        "last_name": "Lee",
        "address_line1": "120 Market Street",
        "city": "Austin",
        "state": "TX",
        "postal_code": "78701",
        "country": "US",
        "phone_number": "5125550142",
    },
    "max_price": WATCH["max_price"],
}, method="POST")

Cron:

*/30 * * * * /usr/bin/python3 /opt/jobs/amazon_autobuy.py

Reuse the same idempotency_key every run for that watch. A second POST returns already_exists with the original order id. Treat that as success, not a new failure. Rotate the key only after a terminal failure you intend to retry as a new purchase. See idempotency.

Wire order.placed and order.failed before you add more ASINs. One successful live order in test mode beats a dashboard full of unhandled 500s.

Mistakes that waste the drop

• Alert-only automation. A webhook to Slack is not a purchase. If the SLA is minutes, call Create Order from the worker, not from an inbox.
• Trusting the chart price. Keepa is excellent history. Checkout adds tax, shipping, and a possible seller change. Always send max_price.
• Scraping checkout. Price HTML is fragile. Payment HTML is worse. Use a purchasing API; do not maintain a headless Amazon cart. That argument is spelled out in web scraping vs ecommerce API.
• Retrying without idempotency. Cron plus a timeout equals two AirPods. Save the key before the first POST.
• Amazon-only when Walmart is cheaper. If the SKU exists on Walmart or Target, compare live offers, then buy the winner.
• No failure path. Sold-out and max_price exceeded are expected. Page an operator or fall back to a second URL.

FAQ

What tool tracks Amazon prices and auto-buys when they drop?

Keepa, CamelCamelCamel, and HARPA track and alert. They do not check out. Alexa auto-buy and ShopSavvy Desktop auto-buy are consumer features tied to one shopper. For software that should place the retailer order, poll price, then call Zinc Create Order with max_price.

How do I build Amazon price tracking without a scraper farm?

Use Keepa, ShopSavvy, or another data API for history and alerts. Use Zinc for the live offer you are willing to buy and for checkout. Skip DIY BeautifulSoup unless you enjoy fixing selectors. Bright Data's Python tracker is a fine data tutorial. It stops before the cart.

Can Keepa place the Amazon order for me?

No. Keepa's job is charts, drops, and seller data. Pair it with a purchasing API if the next step is a shipped box.

Will max_price stop a bad auto-buy?

Yes, for the Zinc order. If the retailer total would exceed the cap, the order fails instead of charging more. It does not freeze Amazon's public price. Poll again later or raise the cap on purpose.

Can an AI agent watch a price and buy the drop?

Yes. Install the Universal Checkout skill, give it the ASIN, cap, and address, and require approval or a hard max_price before it places the order. Setup: agent skills.

Next steps

Keep Keepa on the product page. Add a worker that treats a crossed threshold as an order, not a notification.

Create a key at app.zinc.com, read Create Order, and check pricing before you point cron at a live wallet.

Agent Skilluniversal-checkout

Buy when the Amazon price actually drops

Paste this into Cursor or Claude Code after installing the Universal Checkout skill. The agent checks the live price and only orders if it is still under your cap.

Install and use the universal-checkout Agent Skill from https://github.com/zincio/skills. Watch Amazon https://www.amazon.com/dp/B07JGBW826. If the live total is at or under $79, show me the product, retailer, and total for approval, then place one order to Jordan Lee, 120 Market Street, Austin, TX 78701 with idempotency key watch_B07JGBW826_aug31 and max_price 7900. If it is above $79, do not buy; report the current price instead. Track the order if placed.

Setup guideGitHub