Track Amazon New Releases to Catch Product Launches Early

Amazon's New Releases chart is the earliest public signal that a competitor has shipped a SKU into your category. It ranks products by recency rather than sales, so a launch appears there within days, long before it has the reviews or rank to reach Best Sellers. The Amazon Best Sellers Scraper reads that chart for any category or browse node across 18 marketplaces, returning rank, ASIN, title, price, rating and review count as structured rows you can diff on a schedule.

Why scrape Amazon New Releases for launch detection

By the time a competitor's product shows up on the Best Sellers chart, you have already lost the window to react. Best Sellers is a lagging indicator: it is computed from actual order volume, so a SKU has to sell before it ranks. New Releases is a leading indicator, ranked by how recently a product entered the category. A founder watching the right browse node sees a rival's launch while it still has zero reviews, no ranked keywords and no review moat.

That window matters more than it used to. Independent sellers now account for more than 60% of sales in Amazon's store, which means most of your category's competitive pressure comes from small, fast-moving operators who launch without a press release. There is no announcement to monitor. The chart is the announcement.

Concretely, what you want is a daily snapshot of the New Releases top 100 for the two or three browse nodes you actually compete in, stored so you can diff it. New ASIN today that was not there yesterday, zero reviews, priced 15% under your hero SKU: that is a launch, and you have days rather than months to respond on price, listing copy or ad spend.

How does this compare to the alternatives?

Most teams try to do this manually, and it fails on cadence rather than on capability. Checking a chart in a browser once a week catches launches after they have already started accumulating reviews, and it produces no diffable history. Writing your own scraper is a genuine option, but Amazon throttles aggressively and the chart's second page loads through a follow-up call rather than plain HTML, so a naive script silently returns 30 rows and you never learn what you missed.

How to track Amazon New Releases for launch detection in 4 steps

How do I pull the New Releases chart for my category?

Set listType to newReleases and name the category you compete in. Everything else has a sensible default.

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("thirdwatch/amazon-bestsellers-scraper").call(run_input={
    "categories": ["kitchen"],
    "listType": "newReleases",
    "country": "us",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["asin"], item["title"], item["price"])

A department-level slug like kitchen is useful for orientation, but it is too broad to be an alert. Narrow it in the next step.

How do I narrow this to the browse node I actually compete in?

Pass a browse-node entry, or paste the full chart URL from your browser. Each categories entry produces its own independent top 100, and a full URL overrides both country and listType for that entry — so you can mix nodes, marketplaces and chart types in a single run.

run = client.actor("thirdwatch/amazon-bestsellers-scraper").call(run_input={
    "categories": [
        "kitchen/289913",                                        # slug + browse-node ID
        "https://www.amazon.com/gp/new-releases/home-garden",    # full URL, New Releases
        "https://www.amazon.co.uk/gp/new-releases/grocery",      # different marketplace
    ],
    "listType": "newReleases",
    "country": "us",
    "maxResults": 100,
})

Category slugs are marketplace-specific — amazon.de uses computers where amazon.com uses electronics — so when you are working outside the US, open the chart in a browser and paste the URL rather than guessing a slug.

How do I run this daily and keep a diffable history?

Point an Apify schedule at the actor and let each run write its own dataset. Every row already carries scraped_at, list_type, category_slug and category_url, so snapshots stay self-describing after you export them.

curl -X POST "https://api.apify.com/v2/acts/thirdwatch~amazon-bestsellers-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "categories": ["kitchen/289913", "home-garden"],
        "listType": "newReleases",
        "country": "us",
        "maxResults": 100
      }'

Once daily is the right cadence for launch detection. Amazon recomputes charts roughly hourly, so two runs minutes apart can legitimately differ on ordering without anything having launched.

How do I diff today's chart against yesterday's to find new entrants?

Compare ASIN sets per category. Anything present today and absent yesterday is a candidate launch; anything with a null rating is almost certainly one.

import json

def load(path):
    with open(path) as f:
        return {r["asin"]: r for r in json.load(f)}

yesterday = load("newreleases_2026-07-27.json")
today = load("newreleases_2026-07-28.json")

for asin, row in today.items():
    if asin in yesterday:
        continue
    is_fresh = row.get("rating") is None or (row.get("reviews_count") or 0) < 10
    print(
        f"NEW rank {row['rank']:>3}  {asin}  "
        f"{row['currency_symbol']}{row['price']}  "
        f"{'no reviews yet' if is_fresh else str(row['reviews_count']) + ' reviews'}  "
        f"{row['title'][:60]}"
    )

How do I turn that into an actionable competitor alert?

Filter the new entrants down to the ones that threaten a specific SKU of yours: same node, price within a band of your own, and not yours. by_line carries the brand or author line on media charts; on hard-goods charts match on the title prefix instead.

MY_BRANDS = {"acmeware", "acme home"}
MY_PRICE = 39.99

def is_threat(row):
    brand_text = (row.get("by_line") or row["title"]).lower()
    if any(b in brand_text for b in MY_BRANDS):
        return False                      # our own launch
    price = row.get("price")
    if price is None:
        return False                      # chart showed no price
    return 0.7 * MY_PRICE <= price <= 1.3 * MY_PRICE

threats = [r for r in today.values() if r["asin"] not in yesterday and is_threat(r)]
for r in sorted(threats, key=lambda r: r["rank"]):
    print(r["rank"], r["asin"], r["price"], r["product_url"])

Sample output

Each dataset item is one ranked product on one chart at one point in time. For launch detection the fields that carry the most signal are rank (recency position on a New Releases chart), asin (your join key across snapshots), rating and reviews_count (null or tiny means genuinely new), price plus currency (the launch price band), and scraped_at (the timestamp that makes a diff meaningful). category_url and list_type tell you exactly which chart a row came from, which matters once you are watching several nodes at once.

[
  {
    "rank": 4,
    "asin": "B0F2K7XQZL",
    "title": "Stainless Steel Pour-Over Coffee Kettle, 1.0L Gooseneck",
    "by_line": "",
    "product_format": "",
    "price": 34.99,
    "price_text": "$34.99",
    "price_type": "list",
    "offers_count": null,
    "currency": "USD",
    "currency_symbol": "$",
    "rating": null,
    "rating_text": "",
    "reviews_count": null,
    "reviews_count_text": "",
    "product_url": "https://www.amazon.com/dp/B0F2K7XQZL",
    "image_url": "https://images-na.ssl-images-amazon.com/images/I/71example._AC_UL300_.jpg",
    "reviews_url": "https://www.amazon.com/product-reviews/B0F2K7XQZL",
    "list_type": "newReleases",
    "category_slug": "kitchen",
    "category_node_id": "289913",
    "category_url": "https://www.amazon.com/gp/new-releases/kitchen/289913",
    "page": 1,
    "marketplace": "www.amazon.com",
    "country": "us",
    "source_query": "kitchen/289913",
    "scraped_at": "2026-07-28T06:12:44+00:00"
  },
  {
    "rank": 11,
    "asin": "B0EXAMPLE7",
    "title": "Ceramic Drip Coffee Dripper with Reusable Filter",
    "by_line": "",
    "product_format": "",
    "price": 21.5,
    "price_text": "$21.50",
    "price_type": "from",
    "offers_count": 3,
    "currency": "USD",
    "currency_symbol": "$",
    "rating": 4.3,
    "rating_text": "4.3 out of 5 stars",
    "reviews_count": 7,
    "reviews_count_text": "7",
    "product_url": "https://www.amazon.com/dp/B0EXAMPLE7",
    "image_url": "https://images-na.ssl-images-amazon.com/images/I/61example._AC_UL300_.jpg",
    "reviews_url": "https://www.amazon.com/product-reviews/B0EXAMPLE7",
    "list_type": "newReleases",
    "category_slug": "kitchen",
    "category_node_id": "289913",
    "category_url": "https://www.amazon.com/gp/new-releases/kitchen/289913",
    "page": 1,
    "marketplace": "www.amazon.com",
    "country": "us",
    "source_query": "kitchen/289913",
    "scraped_at": "2026-07-28T06:12:44+00:00"
  }
]

The first row is the classic launch signature: a ranked position, a real price, and nothing in rating or reviews_count. The second is a few weeks older — seven reviews and a price_type of from, meaning Amazon showed a lowest-offer figure rather than a single buy-box price.

Common pitfalls

Sparse ratings are the data, not a bug. On mature Best Sellers charts ratings are present on close to every row. On New Releases they are not: in live testing a UK New Releases chart returned ratings on 56% of rows. Write your alerting to treat rating: null as meaningful rather than filtering those rows out — they are the newest products on the chart.

100 ranks is a hard ceiling. Amazon publishes only the top 100 positions of any chart and errors on a third page, so maxResults is capped at 100 per category. Depth comes from requesting more browse nodes, not a bigger number.

This is chart data, not product detail. There is no description, bullet list, variant set, seller name or stock level. Flag ASINs here, then enrich them with a product-detail scraper.

Slugs do not travel between marketplaces. An unknown slug produces a warning and zero rows for that entry rather than a failed run, which is easy to miss in a scheduled job — check your row counts per source_query. Paste full URLs when working outside the US.

Charts are point-in-time. Amazon recomputes them roughly hourly, so ordering churns without any real launch. Diff on ASIN membership, not on rank movement.

The actor absorbs the mechanical parts of this: rank is read from Amazon's own rank metadata rather than inferred from render order, blocked or truncated responses are detected and retried with a fresh session rather than trusted because they returned HTTP 200, and a category that fails keeps whatever ranks it did collect instead of taking down the run.

Related use cases

Once you have a scheduled chart feed running, the same actor covers several adjacent jobs:

• Track Amazon share of shelf by category — measure what percentage of a category's top 100 your brand owns versus each rival.
• Compare Amazon Best Sellers across marketplaces — judge which country to expand into and at what price band.
• Build an Amazon Best Sellers API feed — expose the charts as your own cached JSON endpoint on a schedule.
• Scrape Product Hunt launches for trend research — the software-side equivalent of launch detection.
• Guide to scraping e-commerce data — the broader category pillar.
• All Thirdwatch guides — every use case, by site and by job.