# Amazon Bestsellers Rank Tracker — Movers & Shakers API (`jaybird/amazon-bestsellers-movers-shakers-tracker`) Actor

Track Amazon Best Sellers & New Releases rank changes: top 100 per category, 11 marketplaces, daily movers, new entrants & dropouts. $4 per 1,000 products.

- **URL**: https://apify.com/jaybird/amazon-bestsellers-movers-shakers-tracker.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** E-commerce, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Bestsellers Rank Tracker — Movers & Shakers API

**Track Amazon Best Sellers rank changes** for any category: every run returns the **full top 100** of Best Sellers or Hot New Releases on **11 marketplaces**, with each product's **previous rank, positions gained, % change**, plus the list's **new entrants, dropouts, biggest risers and fallers**. Schedule it daily and you get **your own Amazon Movers & Shakers feed** — computed with Amazon's own formula — for every category you care about, now that Amazon's own Movers & Shakers pages have shown nothing since spring 2026.

**Highlights:** 📈 rank changes, new entrants & dropouts out of the box · ✅ every ranked product verified, never a silently short list · 🔎 lists by URL, node ID, **keyword** or whole category tree · 🏷️ **track your own ASINs' BSR** in every category · 🌍 US, UK, DE, FR, IT, ES, CA, JP, IN, MX, AU · 💵 **$4 per 1,000 products**

```json
{
    "recordType": "product",
    "listKey": "US:bestsellers:electronics",
    "rank": 2,
    "previousRank": 7,
    "rankChange": 5,
    "rankChangePercent": 250,
    "isNewEntrant": false,
    "asin": "B0DCH8VDXF",
    "title": "Apple EarPods Headphones with USB-C Plug, Wired Ear Buds with Built-in Remote to Control Music, Phone Calls, and Volume",
    "price": 19,
    "priceText": "$19.00",
    "currency": "USD",
    "rating": 4.5,
    "reviewCount": 19026,
    "imageUrl": "https://images-na.ssl-images-amazon.com/images/I/513OSdW4elL._AC_UL900_SR900,600_.jpg",
    "productUrl": "https://www.amazon.com/dp/B0DCH8VDXF",
    "isPrime": false,
    "badges": [],
    "listType": "bestsellers",
    "marketplace": "US",
    "categoryName": "Electronics",
    "categoryPath": "Electronics",
    "listUrl": "https://www.amazon.com/gp/bestsellers/electronics",
    "scrapedAt": "2026-10-15T16:14:35.894Z"
}
```

Plus **one summary record per list** with the biggest risers, fallers, new entrants and dropouts:

```json
{
    "recordType": "summary",
    "listKey": "US:bestsellers:electronics",
    "status": "OK",
    "categoryPath": "Electronics",
    "listTitle": "Best Sellers in Electronics",
    "totalProducts": 100,
    "comparedWithPrevious": true,
    "previousScrapedAt": "2026-10-14T16:00:00.000Z",
    "newEntrantCount": 2,
    "newEntrants": [{ "asin": "B0CQF6T2K1", "rank": 7, "title": "…" }],
    "dropoutCount": 2,
    "dropouts": [{ "asin": "B0F1XYZ123", "title": "…", "previousRank": 5 }],
    "topRisers": [{ "asin": "B09B8V1LZ3", "rank": 10, "previousRank": 39, "rankChange": 29, "rankChangePercent": 290 }],
    "topFallers": [{ "asin": "B0DCH8VDXF", "rank": 2, "previousRank": 1, "rankChange": -1, "rankChangePercent": -50 }]
}
```

### Why use this tracker

- 📈 **Rank tracking built in.** Every run stores a snapshot of each list; the next run returns `previousRank`, `rankChange`, `rankChangePercent`, `isNewEntrant`, plus per-list **new entrants**, **dropouts**, **top risers** and **top fallers**. No spreadsheets, no diffing on your side.
- 🔁 **Movers & Shakers for any category, on your schedule.** `rankChangePercent` uses Amazon's own Movers & Shakers formula (rank 30 → 10 = +200%), so a daily scheduled run gives you a Movers & Shakers view of Best Sellers or New Releases in every category you track — including the ones where Amazon's own page shows nothing.
- ✅ **The whole top 100, verified.** Amazon renders ranks 1–30 in the page and lazy-loads 31–50 (and again on page 2). This actor fetches the lazy-loaded part directly and **checks that every product Amazon lists up to your top N arrived**. A list that comes back short is retried on a fresh session and, if it still can't complete, reported as `FAILED` — never returned as if it were whole. When Amazon itself leaves a position empty or shows "This item is no longer available", the summary says so (`rankGaps`, `unavailableRanks`) instead of hiding it.
- 🔎 **Start from a keyword.** Don't know the category? Type `air fryer` and the actor finds the category the top search results rank in (Air Fryers) and returns that list. Amazon's search no longer has a Department filter, so it reads the Best Sellers Rank of the top organic results instead.
- 🏷️ **Track specific ASINs.** Give it your products (or competitors') and each run returns their Best Sellers Rank in every category they appear in, with the change since the last run.
- 🌳 **Whole category trees.** Start from a department (or all departments) and crawl sub-categories down to the depth you set, with a safety cap on the number of lists.
- 🌍 **11 marketplaces, local prices.** US, UK, DE, FR, IT, ES, CA, JP, IN, MX, AU, with the display currency pinned to the marketplace (EUR on amazon.de, not USD).
- 🛡️ **Battle-tested anti-blocking.** The same datacenter → residential proxy escalation, plain-browser identity and retire-on-captcha stack as our Amazon Product Scraper.
- 🔒 **Public pages only.** No login, ever.

### How to track Amazon Best Sellers rank changes

1. Open the actor and add one or more **list URLs** (e.g. `https://www.amazon.com/gp/bestsellers/electronics`), **category node IDs** or **keywords** — and/or **ASINs** to track.
2. Click **Start**. The first run records a baseline snapshot.
3. **Schedule** the same input (daily is typical). Every later run returns rank changes, new entrants and dropouts against the previous run.
4. Download JSON, CSV or Excel, or read it through the API.

### Input examples

A few lists by URL (the marketplace comes from the domain):

```json
{
    "listUrls": [
        { "url": "https://www.amazon.com/gp/bestsellers/electronics" },
        { "url": "https://www.amazon.de/gp/bestsellers/ce-de" },
        { "url": "https://www.amazon.co.uk/gp/new-releases/books" }
    ],
    "topN": 100
}
```

By category node ID, Best Sellers and New Releases:

```json
{ "categoryNodeIds": ["172541", "12097478011"], "marketplace": "US", "listTypes": ["bestsellers", "new-releases"] }
```

A department and its direct sub-categories, top 20 each:

```json
{ "categoryNodeIds": ["electronics"], "crawlCategoryTree": true, "maxCategoryDepth": 2, "maxLists": 40, "topN": 20 }
```

By keyword (the actor picks the category; it's shown in each list's `source`, e.g. `keyword "air fryer" → Air Fryers`):

```json
{ "keywords": ["air fryer", "yoga mat"], "marketplace": "US", "topN": 50 }
```

Track your own products' Best Sellers Rank:

```json
{ "asins": ["B0BJ1SWDNB", "https://www.amazon.de/dp/B0H4KNCZDN"] }
```

Each tracked ASIN returns one record:

```json
{
    "recordType": "asin",
    "asin": "B0BJ1SWDNB",
    "title": "Olcorife Flat Plug Power Strip with 5 FT Extension Cord, 6 Outlets 3 USB Ports…",
    "marketplace": "US",
    "status": "OK",
    "salesRank": 12,
    "salesRankCategory": "Electronics",
    "previousSalesRank": 15,
    "salesRankChange": 3,
    "ranks": [
        { "rank": 12, "previousRank": 15, "rankChange": 3, "categoryName": "Electronics", "categorySlug": "electronics", "isTopLevel": true },
        { "rank": 2, "previousRank": 2, "rankChange": 0, "categoryName": "Power Strips", "categoryNodeId": "10967801", "isTopLevel": false }
    ]
}
```

| Input | Description |
|---|---|
| `listUrls` | Any Amazon list URL: `/gp/bestsellers/…`, `/gp/new-releases/…`, `/gp/movers-and-shakers/…`, `/gp/most-wished-for/…`, `/gp/most-gifted/…` or `/zgbs/…`. |
| `categoryNodeIds` | Browse node IDs (`172541`) or department slugs (`electronics`, `ce-de`). Combined with `marketplace` and `listTypes`. |
| `keywords` | Product types (`air fryer`). Each resolves to the category its top search results rank in, then fetches that list. Combined with `marketplace` and `listTypes`. |
| `asins` | ASINs or product URLs to track: Best Sellers Rank in every category, with the change since the last run. |
| `marketplace` | `US` (default), `UK`, `DE`, `FR`, `IT`, `ES`, `CA`, `JP`, `IN`, `MX`, `AU`. |
| `listTypes` | `bestsellers` (default), `new-releases`, `movers-and-shakers`, `most-wished-for`, `gift-ideas`. |
| `topN` | Ranks per list, 1–100 (default 100). |
| `crawlCategoryTree` | Also scrape sub-categories. With no URLs or node IDs, starts from all departments. |
| `maxCategoryDepth` | Levels to crawl (default 1). |
| `maxLists` | Cap on lists per run when crawling the tree (default 50). |
| `trackingStoreName` | Named key-value store holding the latest snapshot of each list and ASIN (default `amazon-bestsellers-rank-history`). Clear it to turn tracking off. |
| `previousDatasetId` | Compare with a specific earlier run's dataset instead. |

### How rank tracking works

After each list, the actor saves its ranking (ASIN + rank, up to 100 entries) to the **rank history store**, a named key-value store in your Apify account. The next run that scrapes the same list compares against it:

- **`previousRank` / `rankChange`**: where the product sat last time and how many positions it gained (positive = up).
- **`rankChangePercent`**: Amazon's Movers & Shakers formula, `(previousRank − rank) / rank × 100`.
- **New entrants**: products ranked within last run's top N that weren't there before (`isNewEntrant: true`).
- **Dropouts**: products that were inside today's top N last time and are gone now, listed on the summary record with their previous rank.

Tracked ASINs work the same way, per category: each category's rank is compared with the last run's.

Lists are matched by `listKey` (`marketplace:listType:category`), so a URL, a node ID and a keyword that resolve to the same category share history. Use different `trackingStoreName` values to keep separate histories (e.g. a daily and an hourly schedule).

**Retention:** named key-value stores never expire, so tracking survives indefinitely; each run overwrites a list's snapshot with the newest one. A run's own dataset expires after your plan's data-retention period, so to compare against a specific older day with `previousDatasetId`, keep (name) that dataset.

### What data can it extract?

| Field | Description |
|---|---|
| `rank` | Position in the list, 1–100 |
| `previousRank`, `rankChange`, `rankChangePercent`, `isNewEntrant` | Rank movement since the previous snapshot |
| `asin`, `title`, `productUrl`, `imageUrl` | Product identity (largest image size available) |
| `price`, `priceText`, `listPrice`, `currency` | Price as shown on the list (first number of a range), ISO currency |
| `rating`, `reviewCount` | Star rating and number of ratings |
| `byline`, `format` | Author/artist and format on media lists (books, music, video) |
| `isPrime`, `badges` | Prime flag and card badges, when shown |
| `listType`, `marketplace`, `categoryName`, `categoryNodeId`, `categorySlug`, `categoryPath` | Which list the product came from |
| `salesRankChangePct`, `salesRank`, `salesRank24hAgo` | Amazon's own Movers & Shakers figures, when Amazon shows that list |
| `keyword` | The input keyword a list was resolved from |
| **ASIN record** | `salesRank`, `salesRankCategory`, `previousSalesRank`, `salesRankChange`, and `ranks` (every category with rank, previous rank, change, node ID) — one per tracked ASIN; `status` `NO_RANK` when the product page shows no Best Sellers Rank (common for Amazon devices and some brands) |
| **Summary record** | `status`, `availableProducts`, `totalProducts`, `rankGaps`, `unavailableRanks`, `newEntrants`, `dropouts`, `topRisers`, `topFallers`, `previousScrapedAt` — one per list |

Summary `status` values: `OK`; `EMPTY` (Amazon shows no items for this list); `NOT_FOUND` (Amazon doesn't recognize the category on that marketplace, or a keyword couldn't be matched to a category); `FAILED` (couldn't get a complete list after all retries — the error is in `message`); `BUDGET_LIMIT` (the run hit your maximum cost).

### How much will it cost?

Pay-per-event: **$0.004 per ranked product — $4 per 1,000** — and **$0.004 per tracked ASIN** that shows a Best Sellers Rank, plus **$0.005 per run when it compares with a previous snapshot**, and a negligible $0.00005 actor-start fee. Summary records, empty lists, failed lists and ASINs without a rank are never billed; resolving a keyword to its category is free (you pay for the list it returns). Paid Apify plans get lower prices automatically (down to $3.60 per 1,000 on GOLD and above). Current prices are always on the **Pricing** tab.

Worked example — tracking **10 categories, top 100, once a day**:

- 10 lists × 100 products = 1,000 products × $0.004 = **$4.00**
- rank comparison = $0.005, actor start = $0.00005
- **≈ $4.01 per day**. Tracking only the top 20 of the same 10 categories costs **≈ $0.81 per day**.

Tracking **50 of your own ASINs daily** costs 50 × $0.004 + $0.005 ≈ **$0.21 per day**.

Use `topN` and `maxLists` to bound spend precisely.

### Movers & Shakers, Most Wished For and Gift Ideas

Amazon has shown **no items** on its Movers & Shakers, Most Wished For and Gift Ideas pages since spring 2026, on every marketplace we checked ("Sorry, there are no movers and shakers available in this category"). The actor still accepts these list types and will return their items, including Amazon's own `salesRankChangePct`, if Amazon brings them back. Until then they return an `EMPTY` summary at no charge.

To see the biggest movers today, track **Best Sellers** on a schedule: `topRisers` and `rankChangePercent` give you the same signal Amazon's page used to, for any category.

### Need more product detail?

The list pages carry rank, price, rating and the basics. For **brand, full specs, seller, availability, images and descriptions**, feed the ASINs into our [Amazon Product Scraper](https://apify.com/jaybird/amazon-product-data-scraper). For review text and Amazon's "Customers say" AI summary, use our [Amazon Reviews Scraper](https://apify.com/jaybird/amazon-reviews-scraper). Both chain neatly after this actor with an Apify integration.

### Integrations

Export to **Google Sheets, Google Drive, S3** or a database; automate with **Zapier, Make, n8n and webhooks** (e.g. alert when a product enters your category's top 10); **schedule** recurring runs; or call it from anywhere through the **Apify API** and the JS/Python clients.

### FAQ

**How do I get daily Amazon Best Sellers rank changes?** Schedule this actor with the same input every day. The first run stores a baseline; every run after that returns `previousRank`, `rankChange`, new entrants and dropouts per list automatically.

**Can it get all 100 best sellers in a category?** Yes. Amazon splits each list into two pages of 50 and lazy-loads half of each page; the actor fetches all of it and verifies every listed product arrived. Occasionally Amazon itself skips a rank or shows "This item is no longer available" at one; you then get 99 products and the summary names the position.

**Where do I find a category's node ID?** Open the category's Best Sellers page on Amazon; the number at the end of the URL (e.g. `/gp/bestsellers/electronics/172541`) is the node ID. Or just paste the whole URL into `listUrls` — or type a keyword and let the actor find the category.

**How does keyword mode pick a category?** It searches Amazon for your keyword and reads the Best Sellers Rank on the top organic (non-sponsored) results' product pages, stopping as soon as two of them agree on a sub-category (at most five pages). The winning category and the vote are in the log and in each list's `source`. Broad keywords ("gift") spread across categories; specific product types ("air fryer", "yoga mat") resolve cleanly.

**Can I track my product's Best Sellers Rank (BSR) over time?** Yes. Add its ASIN to `asins` and schedule the actor. Each run returns the rank in every category shown on the product page and the change since the previous run. Some products (Amazon devices, some brands) show no rank on their page; they come back as `NO_RANK` and aren't billed.

**Why is a Movers & Shakers list empty?** Amazon currently shows no Movers & Shakers items on any marketplace we checked. See [above](#movers--shakers-most-wished-for-and-gift-ideas); track Best Sellers to compute movers yourself.

**Why are prices on amazon.de or amazon.co.jp different from what I see?** Amazon prices depend on the visitor's location and delivery address. The actor pins the display currency to the marketplace's own, but it browses anonymously from outside your address, so taxes or shipping-dependent pricing can differ slightly from a logged-in local shopper's view.

**Does it log into Amazon?** No. It reads only public pages, by design.

**Is it legal to scrape Amazon Best Sellers?** The actor collects publicly visible product ranking data and no personal data. Make sure your use complies with Amazon's terms and the laws that apply to you; consult a lawyer if unsure.

### Changelog

**0.1 (October 2026)** — initial release: Best Sellers / New Releases / Movers & Shakers / Most Wished For / Gift Ideas lists by URL, node ID, keyword or category tree; verified top 100; rank tracking with new entrants, dropouts, risers and fallers; per-ASIN Best Sellers Rank tracking; 11 marketplaces; pay-per-event pricing.

Found a bug or need a field added? Open an issue on the **Issues** tab.

# Actor input Schema

## `listUrls` (type: `array`):

Any Amazon list URL, e.g. https://www.amazon.com/gp/bestsellers/electronics, /gp/new-releases/books, /gp/movers-and-shakers/kitchen, /gp/most-wished-for/toys-and-games, /gp/most-gifted/beauty or an SEO-style /zgbs/ URL. The marketplace is taken from the domain.

## `categoryNodeIds` (type: `array`):

Alternative to URLs: Amazon browse node IDs (e.g. 172541 = Headphones on amazon.com) or top-level department slugs (e.g. electronics, books, ce-de on amazon.de). Combined with Marketplace and List types below.

## `keywords` (type: `array`):

Find the category for a product type, then fetch its list: the actor searches Amazon, reads the Best Sellers Rank of the top organic results, and picks the category most of them rank in (e.g. "air fryer" → Air Fryers). The chosen category is shown in each list's summary.

## `asins` (type: `array`):

Track specific products' Best Sellers Rank in every category they rank in, with the change since the last run. Accepts ASINs (B0BJ1SWDNB) or product URLs (which keep their own marketplace).

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

Amazon storefront used for category node IDs, keywords, bare ASINs and category-tree crawls. List and product URLs use their own domain.

## `listTypes` (type: `array`):

Which ranked lists to fetch for each category node ID, keyword or category-tree node. Note: Amazon has shown no Movers & Shakers, Most Wished For or Gift Ideas items since spring 2026; those lists return an EMPTY summary. Use rank tracking on Best Sellers to see the biggest movers yourself.

## `topN` (type: `integer`):

How many ranks to return per list, up to 100 (Amazon's maximum). Every rank up to this number is verified; a list that comes back short is retried and then reported as FAILED rather than returned incomplete.

## `crawlCategoryTree` (type: `boolean`):

Also scrape the sub-categories below each list, down to the depth set below. With no URLs or node IDs, starts from all departments of the selected marketplace.

## `maxCategoryDepth` (type: `integer`):

Levels to crawl. 1 = only the given lists (or, from all departments, the top-level departments); 2 = plus their direct sub-categories; and so on.

## `maxLists` (type: `integer`):

Safety cap on the number of lists one run scrapes when crawling the category tree. Each list is up to 100 products.

## `trackingStoreName` (type: `string`):

Named key-value store in your account where the actor keeps the latest snapshot of every list and tracked ASIN. Each run compares against it, so a scheduled run returns previousRank, rankChange, new entrants and dropouts automatically. Named stores never expire. Clear this field to turn tracking off.

## `previousDatasetId` (type: `string`):

Dataset ID of an earlier run of this actor to compare against instead of the rank history store, e.g. to diff against a specific day.

## `canaryMode` (type: `boolean`):

For scheduled monitoring runs: mark the run as failed (so Apify emails you) if any list, ASIN or keyword fails or a request had to fall back to the residential proxy. Leave off for normal runs.

## Actor input object example

```json
{
  "listUrls": [
    {
      "url": "https://www.amazon.com/gp/bestsellers/electronics"
    }
  ],
  "marketplace": "US",
  "listTypes": [
    "bestsellers"
  ],
  "topN": 100,
  "crawlCategoryTree": false,
  "maxCategoryDepth": 1,
  "maxLists": 50,
  "trackingStoreName": "amazon-bestsellers-rank-history",
  "canaryMode": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "listUrls": [
        {
            "url": "https://www.amazon.com/gp/bestsellers/electronics"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jaybird/amazon-bestsellers-movers-shakers-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 = { "listUrls": [{ "url": "https://www.amazon.com/gp/bestsellers/electronics" }] }

# Run the Actor and wait for it to finish
run = client.actor("jaybird/amazon-bestsellers-movers-shakers-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 '{
  "listUrls": [
    {
      "url": "https://www.amazon.com/gp/bestsellers/electronics"
    }
  ]
}' |
apify call jaybird/amazon-bestsellers-movers-shakers-tracker --silent --output-dataset

```

## MCP server setup

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