# Amazon Best Sellers & Movers Tracker (`zucchini_gopher_m2v/amazon-bestsellers-movers-tracker`) Actor

Track the top 100 Best Sellers in any Amazon category or sub-category, and see exactly what moved since the last run - risers, new entries and drop-outs. Built for FBA sellers and affiliates doing winning-product research. No login needed.

- **URL**: https://apify.com/zucchini\_gopher\_m2v/amazon-bestsellers-movers-tracker.md
- **Developed by:** [Faisal Ahdan naufal](https://apify.com/zucchini_gopher_m2v) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 ranked products

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Amazon Best Sellers & Movers Tracker

Track the **top 100 Best Sellers** in any Amazon category or sub-category —
and see exactly **what moved since your last run**: climbers, new entries and
products that dropped out.

Built for FBA sellers and affiliates doing winning-product research, where
the interesting signal is not "what is #1 today" but "what is climbing fast".

No login, no API key. HTTP-only — no browser.

### What a run gives you

```json
{
  "rank": 41,
  "asin": "B088Z22VYF",
  "title": "Fire TV Stick 4K streaming device",
  "price": 24.99,
  "rating": 4.6,
  "reviewCount": 412903,
  "productUrl": "https://www.amazon.com/dp/B088Z22VYF",

  "previousRank": 71,
  "rankChange": 30,
  "movementType": "RISING",
  "isNewEntry": false,
  "isSignificantMove": true,

  "category": "electronics",
  "listType": "bestsellers",
  "marketplace": "com",
  "hasDetails": true
}
```

`rankChange` is **positive when a product climbs** (a lower rank number is
better). Set `onlyMovers: true` and the dataset contains just the shortlist:

```
RISING       rank=41  prev=71  change=+30   Fire TV Stick 4K
FALLING      rank=6   prev=1   change=-5    Fire TV Stick 4K Plus
NEW_ENTRY    rank=81  prev=—   change=—     (new to the top 100)
DROPPED_OUT  rank=—   prev=77  change=—     (fell out of the top 100)
```

`DROPPED_OUT` products appear nowhere on Amazon's page by definition — they
are only visible by diffing against the previous run.

### ⚠️ About "Movers & Shakers"

Amazon's own Movers & Shakers pages returned **no data in any category
tested** (electronics, books, toys, home, beauty), each showing *"Sorry,
there are no movers and shakers available in this category."*

So this actor **computes the movers itself** from rank snapshots between
runs, which is more dependable than a page Amazon isn't populating — and
gives you drop-outs too, which Amazon's page never showed. Amazon's own
`percentageChange` fields are still read and passed through when present;
they were empty throughout testing.

You can still select `listType: movers-and-shakers`; it will fail with a row
telling you to use `bestsellers` rather than returning an empty dataset.

### Input

```json
{
  "categories": ["electronics", "toys-and-games", "electronics/172541"],
  "listType": "bestsellers",
  "marketplace": "com",
  "maxRank": 100,
  "trackMovement": true,
  "onlyMovers": false
}
```

| Field | Description |
| --- | --- |
| `categories` | Slugs, sub-category node paths (`electronics/172541`), or full Amazon list URLs — a URL overrides marketplace and list type, so one run can mix marketplaces |
| `listType` | `bestsellers` (recommended), `new-releases`, `most-wished-for`, `movers-and-shakers` |
| `marketplace` | com, co.uk, de, fr, it, es, ca, com.au, co.jp, in |
| `maxRank` | Up to 100 (Amazon's ceiling). 50 costs one request, 100 costs two |
| `trackMovement` | Compare against the previous run and label every product |
| `onlyMovers` | Emit only significant moves, new entries and drop-outs |
| `includeDroppedOut` | Emit rows for products that left the list |
| `stateStoreName` | Named store for the snapshot — use different names for independent watchlists |
| `delaySeconds` | Pacing; Amazon serves CAPTCHAs to traffic it dislikes |
| `proxyConfiguration` | Residential recommended for scheduled runs |

### Read this before relying on the output

**About 40% of rows carry rank + ASIN only.** Amazon server-renders just 30
of the 50 product tiles per page; the rest lazy-load. Every product in the
top 100 gets `rank`, `asin` and `productUrl` — but `title`, `price`,
`rating` and `reviewCount` cover roughly 60 of 100. **`hasDetails` marks
which rows are complete**, so filter on it if your pipeline needs price.

(A crawler User-Agent renders all 50 tiles, but that view drops price,
rating and reviews entirely — measured 0/50 on each. More rows, less data,
so it isn't used.)

**Movement quality depends on run cadence.** On the first run everything is
`NEW_ENTRY` because there's nothing to compare against. Schedule it
consistently — daily at the same hour works well — and the deltas become
meaningful.

**CAPTCHAs are reported, never solved.** If Amazon challenges a request the
actor retries with a rotated fingerprint and IP, then emits
`CAPTCHA_ESCALATION` for that list and carries on with the others.

### Known limits

- **Rank 100 is Amazon's ceiling** — no deeper list is served.
- Detail coverage ~60% per the tile split above.
- Amazon's own Movers & Shakers metrics are empty in practice.
- One snapshot per list per run; sub-hourly cadence will mostly capture noise
  rather than signal.

See [CRAWLING\_METHOD.md](CRAWLING_METHOD.md) for the profile ladder results,
the crawler-UA trade-off measurements, and the Movers & Shakers evidence.

# Actor input Schema

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

Category slugs ("electronics", "toys-and-games"), sub-category node paths ("electronics/172541"), or full Amazon list URLs. A full URL overrides the marketplace and list type below, so one run can mix marketplaces.

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

Which ranked list to track. Use 'bestsellers' and let this actor compute the movers - Amazon's own Movers & Shakers pages returned no data in every category tested (see the README).

## `marketplace` (type: `string`):

Amazon domain to track.

## `maxRank` (type: `integer`):

How deep to track. Amazon serves 50 ranks per page and stops at 100, so 100 is the maximum and costs two requests per category.

## `trackMovement` (type: `boolean`):

Compare each run against the previous one and label every product NEW\_ENTRY, RISING, FALLING, UNCHANGED or DROPPED\_OUT, with the exact rank change. This is what turns the actor into a Movers & Shakers tracker; the snapshot lives in a named key-value store so it survives scheduled runs.

## `onlyMovers` (type: `boolean`):

Emit only products that moved significantly (5+ ranks), entered the list, or dropped out - the shortlist for winning-product research. On the very first run everything counts as NEW\_ENTRY because there is nothing to compare against yet.

## `includeDroppedOut` (type: `boolean`):

Emit a row for products that were ranked last run and are not any more. Only visible by diffing snapshots, and a useful signal in its own right.

## `stateStoreName` (type: `string`):

Named key-value store holding the previous run's ranks. Use different names to track separate watchlists independently.

## `delaySeconds` (type: `integer`):

Pause between page fetches. Amazon serves a CAPTCHA to traffic it dislikes, and this actor never solves CAPTCHAs - pacing is what keeps a run clean.

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

Recommended for scheduled runs. Amazon serves CAPTCHAs to datacentre IPs it dislikes; a residential proxy plus the built-in fingerprint rotation avoids them.

## Actor input object example

```json
{
  "categories": [
    "electronics"
  ],
  "listType": "bestsellers",
  "marketplace": "com",
  "maxRank": 100,
  "trackMovement": true,
  "onlyMovers": false,
  "includeDroppedOut": true,
  "stateStoreName": "amazon-rank-state",
  "delaySeconds": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Ranked products with rank-movement analysis.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zucchini_gopher_m2v/amazon-bestsellers-movers-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"] }

# Run the Actor and wait for it to finish
run = client.actor("zucchini_gopher_m2v/amazon-bestsellers-movers-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"
  ]
}' |
apify call zucchini_gopher_m2v/amazon-bestsellers-movers-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zucchini_gopher_m2v/amazon-bestsellers-movers-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/Or7Gi72op1swtUse9/builds/hE4tuABzp3n7Jqn4m/openapi.json