# Amazon Rank Tracker - Keyword Rank Checker (`tiger19935/amazon-keyword-rank-tracker`) Actor

Amazon rank tracker that checks where your ASINs rank for any keyword: organic position, sponsored and video ad position, page, share of shelf by brand and rank change vs the last run. 21 marketplaces. $0.001 per rank check, $0.002 per results page.

- **URL**: https://apify.com/tiger19935/amazon-keyword-rank-tracker.md
- **Developed by:** [Andrew Boiko](https://apify.com/tiger19935) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 search results pages

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 Rank Tracker - Amazon Keyword Rank by ASIN, Ads and Share of Shelf

**Amazon rank tracker** that tells you where your products show up in Amazon search. Give it keywords, ASINs and marketplaces. For every combination it returns the **organic position**, the **sponsored position** (sponsored products, sponsored brands and video ads), the result page, the **share of shelf per brand** and the **rank change since your previous run**. It reads the public search results page (`amazon.<domain>/s?k=...`) over plain HTTP, so there is no browser and no subscription. You pay per results page and per rank check.

### What does Amazon Keyword Rank Tracker do?

For each keyword and marketplace the actor loads the search results pages (1 to 7, you choose the depth), parses every listing in the order Amazon shows it, and works out:

- **Amazon keyword rank, organic:** the position of each tracked ASIN among organic listings only (ads are not counted), plus the page it was on.
- **Sponsored position:** the first sponsored placement of the same ASIN, with the ad type (`sponsored-product`, `sponsored-brand`, `video`). Organic and sponsored ranks are kept apart, so you see what you earn and what you pay for.
- **Share of shelf:** for every keyword, the share of organic and sponsored listings held by each brand (top 10 brands plus any brands you list). Brands come from the listing, from your `brands` input, or are marked as `title-guess` when only the product title was available.
- **Rank change (delta):** the actor stores each result in a named key-value store. On the next run with the same `stateKey` it reports the previous rank and the change. A positive `organicDelta` means the product moved up.
- **Many marketplaces in one run:** amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .com.au, .in, .co.jp, .com.mx, .com.br, .nl, .se, .pl, .sg, .ae, .sa, .com.tr, .com.be and .eg.

If Amazon shows a robot check (captcha) the actor discards that session, takes a new proxy IP and retries. Searches that cannot be completed are listed in the run summary and are never charged.

### Why use Amazon Keyword Rank Tracker?

1. **Organic and ad rank in the same row.** Many simple trackers return a single position. Here you get organic rank, sponsored rank, ad type and page for each ASIN.
2. **Share of shelf and history built in.** Brand share per keyword and rank deltas versus the last run need no extra tooling: schedule the actor daily or weekly and read the `organicDelta` column.
3. **Pay per use instead of a monthly plan.** A results page costs $0.002 and a rank check costs $0.001 on the free tier, less on paid Apify plans. Tracking 20 keywords x 3 ASINs on amazon.com with 3 pages each costs about $0.18 per run. There is no seat fee and no minimum.
4. **Open data, any workflow.** JSON, CSV, Excel, API, webhooks, n8n, Make, Zapier, Google Sheets and MCP.

### How much does it cost to scrape Amazon keyword rank data?

Pay-per-event pricing. Apify's per-run start event is not changed by this actor.

| Event | What is billed | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| `serp-page` | one search results page fetched and parsed | $0.0020 | $0.0018 | $0.0016 | $0.0014 |
| `rank-check` | one completed keyword x ASIN x marketplace rank row | $0.0010 | $0.0009 | $0.0008 | $0.0007 |

Examples on the FREE price list:

- 1 keyword, 1 ASIN, 1 marketplace, 2 pages = 2 x $0.002 + 1 x $0.001 = **$0.005**.
- 100 keywords x 5 ASINs, amazon.com, 3 pages = 300 pages + 500 checks = $0.60 + $0.50 = **$1.10**.
- 1,000 results pages with no ASINs (share of shelf only) = **$2.00**.

What is and is not charged:

- A rank row is charged when the search finished for the scanned depth, including "not found in the first N pages" (that is a real answer for a tracker).
- Searches blocked by Amazon, pages that failed, and share-of-shelf rows are not charged as rank checks. If a search stops half way, ASINs not yet found are reported as unknown: no row and no charge.
- **Free tier:** users on the free Apify plan get up to 25 result rows per run, then the run ends normally with the message "Free tier limit reached (25 results). Upgrade to a paid Apify plan for unlimited results."
- Set **maxTotalChargeUsd** on the run to cap spending. The actor stops gracefully when the limit is reached.

### Input

| Field | Type | Description |
|---|---|---|
| `keywords` | array of strings | Search phrases to check. |
| `asins` | array of strings | ASINs to track. Product URLs containing `/dp/ASIN` are accepted. Empty = share of shelf only. |
| `marketplaces` | array | Domains such as `com`, `co.uk`, `de`, `fr`, `it`, `es`, `ca`, `com.au`, `in`. |
| `maxPages` | integer 1-7 | Search depth per keyword and marketplace. Default 2. |
| `brands` | array of strings | Brands always shown in share of shelf and recognised in titles. |
| `zipCode` | string | Optional delivery ZIP or postal code (best effort). |
| `includeSponsored` | boolean | Report sponsored positions. Default true. |
| `compareWithPrevious` | boolean | Save history and report rank change. Default true. |
| `stateKey` | string | Name of the history. Runs with the same key are compared. Default `default`. |
| `maxItems` | integer | Stop after this many dataset rows. 0 = no limit. |
| `maxConcurrency` | integer | Parallel searches. Default 2. |
| `maxRetries` | integer | Retries per page with a fresh session and IP. Default 4. |
| `proxyConfiguration` | object | Apify proxy settings. Default: datacenter proxy matching the marketplace country. |
| `useResidentialFallback` | boolean | Switch to residential proxy when the first proxy keeps getting blocked. Default false. |

Example 1, one product on amazon.com:

```json
{
  "keywords": ["wireless earbuds"],
  "asins": ["B0BDHWDR12"],
  "marketplaces": ["com"],
  "maxPages": 2
}
```

Example 2, weekly multi-marketplace tracking with history:

```json
{
  "keywords": ["wireless earbuds", "bluetooth headphones"],
  "asins": ["B0BDHWDR12", "B09JQMJHXY"],
  "marketplaces": ["com", "co.uk", "de", "fr"],
  "maxPages": 3,
  "stateKey": "client-acme-weekly",
  "useResidentialFallback": true
}
```

Example 3, share of shelf for brands without ASINs:

```json
{
  "keywords": ["whey protein"],
  "asins": [],
  "brands": ["Optimum Nutrition", "MyProtein"],
  "marketplaces": ["com"],
  "maxPages": 3
}
```

### Output example

Each rank row looks like this (illustrative values, not from a live run):

```json
{
  "type": "rank",
  "marketplace": "com",
  "keyword": "wireless earbuds",
  "asin": "B0BDHWDR12",
  "status": "ranked",
  "organicPosition": 7,
  "organicPage": 1,
  "organicAbsolutePosition": 11,
  "sponsoredPosition": 2,
  "sponsoredPage": 1,
  "sponsoredAdTypes": ["sponsored-product"],
  "page": 1,
  "title": "Example Brand Wireless Earbuds, Noise Cancelling",
  "brand": "Example Brand",
  "price": "$189.00",
  "rating": 4.6,
  "url": "https://www.amazon.com/dp/B0BDHWDR12",
  "previousOrganicPosition": 9,
  "organicDelta": 2,
  "previousSponsoredPosition": null,
  "sponsoredDelta": null,
  "organicTrend": "up",
  "pagesChecked": 2,
  "resultsScanned": 58,
  "checkedAt": "2026-10-19T09:00:00.000Z"
}
```

And one share-of-shelf row per keyword and marketplace:

```json
{
  "type": "shelf",
  "marketplace": "com",
  "keyword": "wireless earbuds",
  "pagesChecked": 2,
  "organicResults": 44,
  "sponsoredResults": 14,
  "topBrands": [
    { "brand": "Example Brand", "organicCount": 6, "organicSharePct": 13.6, "sponsoredCount": 3, "sponsoredSharePct": 21.4, "bestOrganicPosition": 2, "brandSource": "listing", "organicShareChangePct": 1.1 }
  ],
  "checkedAt": "2026-10-19T09:00:00.000Z"
}
```

`status` is `ranked` (organic position found), `sponsored-only` (found only as an ad) or `not-found` (not within the scanned pages). `organicTrend` is `up`, `down`, `unchanged`, `entered`, `lost` or `new` (no history yet). The run summary with counts, charged events, blocked pages and warnings is saved to the `OUTPUT` record of the default key-value store.

### How to use Amazon Keyword Rank Tracker (tutorial)

1. **Open the actor** in Apify Console and click Try for free.
2. **Add keywords and ASINs.** Paste your search phrases and the ASINs you want to track. Pick one or more marketplaces.
3. **Choose the depth.** Two pages cover roughly the top 30 to 90 listings. More pages cost more and show where a weak product sits.
4. **Set a state key and run.** The first run stores the baseline. Use the same `stateKey` in every later run to get rank changes.
5. **Schedule it.** Create a schedule (daily or weekly), then connect the dataset to Google Sheets, a webhook or your BI tool and chart `organicPosition` over time.

Rankings depend on location, language and Prime eligibility. Compare runs that use the same marketplace, proxy country and ZIP.

### Run via API

```bash
curl -X POST "https://api.apify.com/v2/acts/tiger19935~amazon-keyword-rank-tracker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["wireless earbuds"],"asins":["B0BDHWDR12"],"marketplaces":["com"],"maxPages":2}'
```

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('tiger19935/amazon-keyword-rank-tracker').call({
    keywords: ['wireless earbuds'],
    asins: ['B0BDHWDR12'],
    marketplaces: ['com', 'co.uk'],
    maxPages: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => i.type === 'rank'));
```

**MCP:** the inputs are plain arrays, so AI agents can call this actor through the Apify MCP server, for example "where does ASIN B0BDHWDR12 rank for wireless earbuds on amazon.de?".

### Integrations

- **Google Sheets:** append each run's dataset to a sheet and chart rank over time.
- **n8n, Make and Zapier:** trigger on run finished, then post rank drops to Slack or email.
- **Webhooks:** call your own endpoint when a run succeeds and read `organicDelta` from the dataset.
- **Schedules:** daily or weekly runs are the normal way to use a rank tracker.
- **MCP and API:** see above.

### Legal / ethical use

The actor reads publicly visible Amazon search result pages. It does not log in, use cookies from your account or access private data. Amazon's terms restrict automated access, so you are responsible for how you use the data, for respecting rate limits and for compliance with the terms of the sites you query and with local law. The data is product and ranking information, not personal data. Use moderate concurrency and sensible schedules.

### FAQ and support

**What is the difference between organic and sponsored position?**
Organic position counts only non-advertised listings in the order Amazon shows them. Sponsored position counts sponsored products, sponsored brands and video ads separately. `organicAbsolutePosition` also includes ads.

**Why does my rank differ from what I see in my browser?**
Amazon personalises and localises results (delivery location, Prime, language, A/B tests). Use the same marketplace, proxy country and ZIP between runs and compare the trend, not single values.

**Does the ZIP / delivery location work?**
It is a best-effort feature: the actor tries to set the location through Amazon's location widget and logs a warning if Amazon does not accept it. The row field `deliveryLocation` shows what the page reported.

**What happens on a captcha or robot check?**
The actor drops the session, takes a new proxy IP and retries up to `maxRetries` times. If the proxy keeps being blocked, enable `useResidentialFallback` (residential traffic is billed by Apify) or lower `maxConcurrency`. Failed searches are listed in `OUTPUT` and are not charged.

**How is the share of shelf calculated?**
Brand listings divided by all scanned organic (or sponsored) listings for the keyword and marketplace. Where Amazon does not show a brand, the actor uses your `brands` input, and otherwise the first word of the title, marked `brandSource: "title-guess"`.

**How many results does one page hold?**
Typically 16 to 48 listings including ads. Amazon usually serves up to 7 pages per search.

**Where is the history stored?**
In a named key-value store called `amazon-rank-<stateKey>` in your account, one record per marketplace and keyword, with up to 60 snapshots.

**Can I track a product that is not on page 1?**
Yes, raise `maxPages` up to 7. Products beyond the scanned pages are reported as `not-found`.

Questions or a broken marketplace layout? Open an issue in the Issues tab. Replies within 12 hours.

### More tools by the same author

- [Prozorro & TED Tenders Scraper](https://apify.com/tiger19935/prozorro-ted-tenders-scraper) - public tenders from Ukraine and the EU
- [Billing & Payment Stack Detector](https://apify.com/tiger19935/billing-stack-detector) - which payment gateway a website uses
- [Website Technology Detector](https://apify.com/tiger19935/website-technology-detector) - tech stack of any site
- [Decision-Maker Contacts](https://apify.com/tiger19935/decision-maker-contacts) - people and roles at a company

### Related searches

Amazon rank tracker, amazon rank tracker scraper, amazon rank tracker api, amazon rank tracker data, amazon rank tracker to csv, amazon rank tracker monitor, amazon rank tracker apify, amazon rank tracker mcp, amazon keyword rank, amazon keyword rank scraper, amazon keyword rank api, amazon keyword rank data.

# Changelog

This Actor's version history is a separate document: https://apify.com/tiger19935/amazon-keyword-rank-tracker/changelog.md

# Actor input Schema

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

Search phrases to check, exactly as a shopper would type them. One Amazon search is run per keyword and marketplace.

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

ASINs (10 characters, for example B0BDHWDR12) whose rank you want. Leave empty to only collect share of shelf for each keyword.

## `marketplaces` (type: `array`):

Amazon domains to search. Each marketplace is checked separately, so ranks are per country.

## `maxPages` (type: `integer`):

How many result pages to read per keyword and marketplace (about 16 to 48 results per page, Amazon shows at most 7). Each page is one serp-page event.

## `brands` (type: `array`):

Optional brand names (for example your brand and competitors). They are always listed in the share-of-shelf row and used to recognise the brand in product titles.

## `zipCode` (type: `string`):

Optional. Try to set the delivery location before searching (best effort, mainly amazon.com, .ca, .co.uk, .de). Leave empty for the default location of the proxy IP. Rankings can differ by location.

## `includeSponsored` (type: `boolean`):

Report sponsored position (sponsored products, sponsored brands and video ads) separately from organic position.

## `compareWithPrevious` (type: `boolean`):

Save each result to a named key-value store and report the rank change versus the previous run for the same state key.

## `stateKey` (type: `string`):

Name of the history. Runs that share the same key (letters, digits, hyphens) are compared with each other. Use a different key per project or client.

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

Stop after this many dataset rows (rank rows and share-of-shelf rows). 0 means no limit.

## `maxConcurrency` (type: `integer`):

How many keyword and marketplace searches run at the same time. Keep low to avoid Amazon robot checks.

## `maxRetries` (type: `integer`):

How often a page is retried with a fresh session and proxy IP after a robot check, block or server error.

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

Amazon blocks many datacenter IPs. The default Apify datacenter proxy is tried first, with a country matching the marketplace.

## `useResidentialFallback` (type: `boolean`):

When Amazon keeps blocking the configured proxy, switch to Apify residential proxy for the rest of the run. Residential traffic is billed by Apify to your account.

## Actor input object example

```json
{
  "keywords": [
    "wireless earbuds"
  ],
  "asins": [
    "B0BDHWDR12"
  ],
  "marketplaces": [
    "com"
  ],
  "maxPages": 2,
  "brands": [],
  "zipCode": "",
  "includeSponsored": true,
  "compareWithPrevious": true,
  "stateKey": "default",
  "maxItems": 0,
  "maxConcurrency": 2,
  "maxRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "useResidentialFallback": false
}
```

# Actor output Schema

## `ranks` (type: `string`):

One row per keyword, ASIN and marketplace, plus one share-of-shelf row per keyword and marketplace.

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

Full dataset with every field.

## `summary` (type: `string`):

Counts, charged events, estimated cost, blocked pages and warnings.

# 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 = {
    "keywords": [
        "wireless earbuds"
    ],
    "asins": [
        "B0BDHWDR12"
    ],
    "marketplaces": [
        "com"
    ],
    "maxPages": 2,
    "brands": [],
    "zipCode": "",
    "includeSponsored": true,
    "compareWithPrevious": true,
    "stateKey": "default",
    "maxItems": 0,
    "maxConcurrency": 2,
    "maxRetries": 4,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "useResidentialFallback": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("tiger19935/amazon-keyword-rank-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 = {
    "keywords": ["wireless earbuds"],
    "asins": ["B0BDHWDR12"],
    "marketplaces": ["com"],
    "maxPages": 2,
    "brands": [],
    "zipCode": "",
    "includeSponsored": True,
    "compareWithPrevious": True,
    "stateKey": "default",
    "maxItems": 0,
    "maxConcurrency": 2,
    "maxRetries": 4,
    "proxyConfiguration": { "useApifyProxy": True },
    "useResidentialFallback": False,
}

# Run the Actor and wait for it to finish
run = client.actor("tiger19935/amazon-keyword-rank-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 '{
  "keywords": [
    "wireless earbuds"
  ],
  "asins": [
    "B0BDHWDR12"
  ],
  "marketplaces": [
    "com"
  ],
  "maxPages": 2,
  "brands": [],
  "zipCode": "",
  "includeSponsored": true,
  "compareWithPrevious": true,
  "stateKey": "default",
  "maxItems": 0,
  "maxConcurrency": 2,
  "maxRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "useResidentialFallback": false
}' |
apify call tiger19935/amazon-keyword-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tiger19935/amazon-keyword-rank-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/EKItae3AEI5FkVYl2/builds/pau1HRx0ekrtktAFK/openapi.json