# Amazon Best Sellers Tracker — Rank Movement & New Entrants (`alaudinburki/amazon-bestsellers-tracker`) Actor

Track Amazon Best Sellers, New Releases and Movers & Shakers across 16 marketplaces, and get what CHANGED: new entrants, climbers, fallers and drop-outs with a signal explaining each move. Currency is read from the page rather than assumed, because Amazon geolocates prices.

- **URL**: https://apify.com/alaudinburki/amazon-bestsellers-tracker.md
- **Developed by:** [alaudin burki](https://apify.com/alaudinburki) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Amazon Best Sellers Tracker — Rank Movement & New Entrants

The top-100 list is on the page for anyone to read. **The value is in the movement.**

A product entering the chart, or climbing 40 places overnight, is a trend starting — and that is what
sellers, brands and sourcing teams actually watch for. This keeps a snapshot between runs and tells you
what **changed**.

Covers **16 marketplaces** and all three Amazon charts: Best Sellers, New Releases, and Movers & Shakers.

### What you get beyond the list

| Field | Description |
|---|---|
| **`movement`** | `new_entrant` · `climbing` · `falling` · `unchanged` |
| **`climbedBy`** | **Places gained** — positive means it moved *up*. (Rank deltas are inverted and easy to misread, so this is stated the human way.) |
| **`signal`** | `breakout` · `surging` · `rising` · `steady` · `easing` · `sliding` · `new` |
| **`note`** | What that move usually means — e.g. a sharp fall suggests a stock-out, a price rise, or a new competitor |
| `previousRank` | Where it was last run |
| `rank` · `asin` · `title` · `price` · `currency` · `stars` · `reviewCount` · `url` | The listing itself |

Drop-outs — products that were on the chart and no longer are — are listed in `QUALITY_REPORT`.

**Signals are position-weighted.** A new entrant at rank 3 is a `breakout`; the same event at rank 87 is
just `new`. A 6-place climb inside the top 10 matters more than a 6-place climb at rank 60.

### Input

```json
{
  "categories": ["electronics", "home-garden"],
  "country": "us",
  "listType": "bestsellers",
  "trackRankChanges": true
}
```

Category slugs come from any Best Sellers URL. Full URLs work too.

**Run it daily** — that's the point. The first run has nothing to compare against, so everything is a
`new_entrant`; the second run is where the data starts. Set `moversOnly: true` to turn a 100-row chart
into a short list of what actually changed.

### ⚠️ Two honest limits, both verified on real runs

#### 1. Amazon does not serve the whole chart in HTML

Amazon server-renders about **30 of each 50-item page**; the rest load with JavaScript and are simply
not in the response. Measured on a real run with `pages: 2`: ranks **1–30 and 51–80** came back, and
**31–50 were absent**.

This actor **tells you which rank numbers are missing** in `QUALITY_REPORT` rather than handing you 60
rows labelled "top 100". A partial chart presented as complete is how you end up with wrong trend
analysis.

#### 2. Amazon prices are geolocated

Prices follow the **exit IP**, not the domain. During development `amazon.com` returned prices in **PKR**,
and an incorrectly configured proxy returned **CAD** — both from the US site.

So the currency is **parsed from the page, never assumed**, reported on every row, and
`QUALITY_REPORT.currencyWarning` fires if it doesn't match the marketplace. The default proxy is Apify
residential in the marketplace country, which is what makes it come back correct.

If you see an unexpected currency, your proxy country is wrong — the actor will say so rather than
quietly giving you numbers in the wrong money.

### Sample output

```json
[
  {
    "rank": 4,
    "asin": "B0DCH8VDXF",
    "title": "Apple EarPods Headphones with USB-C Plug",
    "price": 17.99,
    "currency": "USD",
    "stars": 4.5,
    "previousRank": 22,
    "climbedBy": 18,
    "movement": "climbing",
    "signal": "surging",
    "note": "Up 18 places to rank 4. Sharp moves near the top usually mean a promotion, a review spike, or a competitor going out of stock.",
    "category": "electronics",
    "status": "ok"
  }
]
```

### Typical uses

- **Product research** — new entrants are demand signals before the category gets crowded.
- **Competitor monitoring** — know the day a rival's product starts climbing, not the month after.
- **Brand protection** — a sudden fall usually means a stock-out or an unauthorised seller undercutting you.
- **Sourcing and dropshipping** — Movers & Shakers is the fastest-moving demand signal Amazon publishes.
- **Trend datasets** — daily snapshots build history that cannot be back-filled later.

### Pricing

**$2.00 / 1,000 products** (`$0.002` per result), plus a near-zero start fee. A daily run over 5
categories costs a few cents a month. Never charged beyond `maxItems`.

### FAQ

- **Do I need a proxy?** Yes, effectively. Amazon blocks datacenter IPs and geolocates prices. The
  default (Apify residential, matched to the marketplace) is already set.
- **Why only ~30 products per page?** See the limit above — it's Amazon, not the parser, and the
  missing ranks are reported.
- **Can I get the full top 100?** Set `pages: 2` for ranks 1–30 and 51–80. The lazy-loaded ranks cannot
  be retrieved from HTML.
- **How often should I run it?** Daily. Two runs an hour apart mostly measures noise.
- **Does it work outside the US?** Yes — 16 marketplaces, and the proxy country follows automatically.

### Related actors

- **Amazon Product Scraper** — full detail for any ASIN you find here.
- **Amazon Reviews Scraper** — voice-of-customer on a product that is climbing.
- **App Store Charts Tracker** — the same movement-tracking idea for mobile apps.

# Actor input Schema

## `categories` (type: `array`):

Category slugs (electronics, books, toys-and-games) or full Best Sellers URLs. Find a slug in any Best Sellers page URL.

## `country` (type: `string`):

Which Amazon marketplace to read. Prices are geolocated, so the proxy country is matched to this automatically.

## `listType` (type: `string`):

Best Sellers (top 100 by sales), New Releases (recent launches climbing), or Movers & Shakers (biggest 24h rank gains).

## `pages` (type: `integer`):

Amazon publishes two pages of 50. 1 gives the top 50, 2 gives the full top 100.

## `trackRankChanges` (type: `boolean`):

Compare against the previous run to report new entrants, climbers, fallers and drop-outs. This is the reason to schedule the actor — the first run has nothing to compare to.

## `moversOnly` (type: `boolean`):

Return only new entrants, climbers and fallers — skip products holding the same rank. Turns a 100-row chart into a short list of what actually changed.

## `concurrency` (type: `integer`):

Keep this low. Amazon rate-limits aggressively and a bot check wastes the whole run.

## `snapshotKey` (type: `string`):

Key-value store key holding the previous run's ranks. Use different keys to track several category sets independently.

## `maxItems` (type: `integer`):

Hard cap on products returned. You are never charged beyond this.

## `proxyConfiguration` (type: `object`):

Defaults to Apify residential proxy in the marketplace country. Amazon geolocates prices and blocks datacenter IPs, so changing this usually makes results worse.

## Actor input object example

```json
{
  "categories": [
    "electronics",
    "home-garden"
  ],
  "country": "us",
  "listType": "bestsellers",
  "pages": 1,
  "trackRankChanges": true,
  "moversOnly": false,
  "concurrency": 3,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Best-seller ranks with movement vs the previous run.

## `qualityReport` (type: `string`):

New entrants, drop-outs, currency check and any bot-check problems.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "categories": [
        "electronics",
        "home-garden"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alaudinburki/amazon-bestsellers-tracker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "categories": [
        "electronics",
        "home-garden",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("alaudinburki/amazon-bestsellers-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "categories": [
    "electronics",
    "home-garden"
  ]
}' |
apify call alaudinburki/amazon-bestsellers-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alaudinburki/amazon-bestsellers-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hknvzvN74BRPLjMM5/builds/Q6so5lbmRe1CnhYT1/openapi.json