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

Track where your ASINs rank on Amazon for each keyword: organic rank, sponsored position and page, on 20 marketplaces, with the rank change since the last run. Schedule it daily for a keyword rank history. No login.

- **URL**: https://apify.com/molded_mountainpass/amazon-keyword-rank-tracker.md
- **Developed by:** [Divya Raj](https://apify.com/molded_mountainpass) (community)
- **Categories:** E-commerce, SEO tools, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 rank rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Amazon Keyword Rank Tracker do?

**Amazon Keyword Rank Tracker** checks **where your products rank on Amazon for each keyword**. Give it keywords and ASINs, pick a marketplace, and every row tells you one ASIN's **organic rank**, its **position** as shoppers see it (ads included), its **page**, and whether it also shows up as a **sponsored ad**. It works on **20 Amazon marketplaces** (amazon.com, .co.uk, .de, .fr, .it, .es, .ca, .co.jp, .in, .com.au and more).

The Actor remembers each keyword's last ranks, so every row also has the **rank change since the last run** (`rankDelta`). Schedule it daily on Apify and you have an **Amazon keyword rank history** for your products and your competitors', with API access, Google Sheets, Make and Zapier integrations, and webhooks.

**Try it:** the input is prefilled with three earbud ASINs and the keyword "wireless earbuds". Click **Start**.

### How to track Amazon keyword rankings

1. Enter your **Keywords**.
2. Enter the **ASINs to track** (yours and your competitors'). Leave it empty to get the rank of every product.
3. Pick a **Marketplace** and how many **pages** to look through (3 pages = the top ~48 organic results).
4. Click **Start**, then download the ranks as JSON, CSV, Excel or HTML, or read them through the API.
5. To build a history, create a **Schedule** (for example daily). Each run compares with the last one.

### Output example

One row per ASIN per keyword (and one more if the ASIN is also advertised on that keyword):

```json
{
    "searchQuery": "wireless earbuds",
    "marketplace": "US",
    "asin": "B09FT58QQP",
    "title": "TOZO A1 Wireless Earbuds Bluetooth 5.3 Light Weight in Ear Headphones",
    "organicRank": 6,
    "positionOverall": 6,
    "isSponsored": false,
    "page": 1,
    "positionOnPage": 6,
    "changeType": "changed",
    "rankDelta": -3,
    "previousRank": 9,
    "price": { "value": 13.96, "currency": "$", "raw": "$13.96", "currencyCode": "USD" },
    "stars": 4.3,
    "reviewsCount": 118344,
    "purchaseVolumeText": "10K+ bought in past month",
    "url": "https://www.amazon.com/dp/B09FT58QQP",
    "scrapedAt": "2026-10-21T16:18:17Z"
}
```

| Field | Meaning |
| :--- | :--- |
| `organicRank` | Rank among organic (non-sponsored) results, across pages. Empty on sponsored rows. |
| `positionOverall` | Position counting every product card, ads included, as a shopper sees it. |
| `isSponsored`, `adType` | Whether this row is an ad, and which kind (`sponsored_product`, `video`, `brand_banner`). |
| `page`, `positionOnPage` | Where on which result page it was found. |
| `changeType` | `new` (first time seen for this keyword), `changed` or `unchanged`. |
| `rankDelta`, `previousRank` | Rank move since the last run; negative means it moved **up**. |
| `price`, `stars`, `reviewsCount`, `badges`, `purchaseVolumeText` | The listing's details on the results page. |

An ASIN that isn't in the pages read gets a free `notFound` row (`found: false`) so you know it was checked: raise **Max pages** to look deeper. **Rank changes** can also be set to output only the ASINs whose rank moved.

### How much does it cost to track Amazon keyword ranks?

You pay **$0.01 per rank row** ($10 per 1,000; one row = one ASIN found for one keyword) and **$0.005 per run**. Proxies and platform usage are included. Tracking 5 ASINs on 20 keywords is at most 100 rows, so at most about **$1 per run**; `notFound` rows for ASINs outside the pages read are free. Set a **Maximum cost per run** in Run options to cap any run.

**Free to try:** Apify's free plan includes $5 of platform credit every month, enough for about 500 rank rows, so you can use it as a free Amazon keyword rank tracker for a few ASINs.

### Need more than ranks? Use Amazon Search Scraper

This Actor is a focused version of **[Amazon Search Scraper](https://apify.com/molded_mountainpass/amazon-search-scraper)**. Use the full Actor to get **every product** on the results page (not just tracked ASINs), filters (price, stars, Prime, sort order), Amazon search URLs as input, sponsored ad monitoring, and a real-time Standby API.

### Tips

- Keep **Residential** proxies (the default): Amazon serves reduced pages or CAPTCHAs to datacenter IPs.
- Set a **Delivery ZIP or postal code** to see the ranks shoppers in that area see.
- Use one **Monitoring store name** per client to keep separate rank histories.

### FAQ

**Is it legal to scrape Amazon?** This Actor collects only publicly visible, non-personal product data from search result pages. Scraping public data is generally lawful in many jurisdictions, but it depends on your location, purpose and the applicable terms. Review Amazon's Terms of Service and consult your own legal counsel. You're responsible for how you use the output.

**Why is an ASIN `notFound`?** It wasn't in the result pages read (raise Max pages), or Amazon served a reduced page; the run's `RUN_STATS` record lists pages read, CAPTCHAs and rows by type.

**Known limitations.** Ranks change with location, time and personalisation, so expect small differences from what you see in your own browser. **amazon.fr** currently answers with a JavaScript robot check, so FR searches return a free error row.

Found a bug or need a feature? Open a ticket on the **Issues** tab.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to check. Each keyword is searched on the marketplace below, and every row says which keyword it ranks for (`searchQuery`).

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

Your products and your competitors' (10-character ASINs, e.g. B09FT58QQP). Each row is one ASIN found for one keyword, with its organic rank and its position. Leave empty to get the rank of every product in the results.

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

Amazon marketplace to check the ranks on.

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

How deep to look: about 16 organic results per page, so 3 pages = the top ~48. An ASIN that isn't in the pages read gets a free notFound row (found: false).

## `monitoringMode` (type: `string`):

The Actor remembers each keyword's last ranks. With history on, rows get changeType (new / changed / unchanged), rankDelta (negative = moved up) and previousRank. Schedule it daily to build a rank history.

## `rankChangeThreshold` (type: `integer`):

For 'Only ASINs whose rank or price changed': how many places a rank must move to count.

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

Also report where the ASINs appear as sponsored ads. Off: organic ranks only. Ads still count in the position shoppers see.

## `deliveryZipCodes` (type: `object`):

Prices, delivery dates and availability depend on where Amazon delivers. Give a postcode per marketplace, by country code or domain, for example {"US": "10001", "DE": "10115", "amazon.co.uk": "SW1A 1AA"}. No extra charge. Rows show deliveryLocation and zipApplied (whether Amazon accepted it).

## `monitorStoreName` (type: `string`):

Named key-value store that keeps the last ranks. Use a different name to keep separate histories, for example one per client.

## `language` (type: `string`):

Language the Actor asks Amazon for (Accept-Language). Auto uses the marketplace's own language, for example German on amazon.de. Pick English to get English text everywhere Amazon offers it.

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

Amazon blocks datacenter IPs, so RESIDENTIAL is the default. Datacenter proxies cost less but often return few or no results.

## `scrapeMode` (type: `string`):

Fixed: this Actor outputs search-result rows.

## `maxResultsPerQuery` (type: `integer`):

0 = no limit; Max pages limits the run.

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

How many pages are fetched at the same time. The pages of one keyword are always read in order, so this speeds up runs with several keywords. 3-5 is reliable; more is faster but meets more temporary blocks.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "asins": [
    "B0FQFB8FMG",
    "B09FT58QQP",
    "B0CRTR3PMF"
  ],
  "country": "US",
  "maxPages": 3,
  "monitoringMode": "all",
  "rankChangeThreshold": 1,
  "includeSponsored": true,
  "monitorStoreName": "amazon-rank-tracker",
  "language": "AUTO",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "scrapeMode": "search",
  "maxResultsPerQuery": 0,
  "concurrency": 5
}
```

# Actor output Schema

## `results` (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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "asins": [
        "B0FQFB8FMG",
        "B09FT58QQP",
        "B0CRTR3PMF"
    ],
    "country": "US",
    "maxPages": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("molded_mountainpass/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 = {
    "searchQueries": ["wireless earbuds"],
    "asins": [
        "B0FQFB8FMG",
        "B09FT58QQP",
        "B0CRTR3PMF",
    ],
    "country": "US",
    "maxPages": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("molded_mountainpass/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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "asins": [
    "B0FQFB8FMG",
    "B09FT58QQP",
    "B0CRTR3PMF"
  ],
  "country": "US",
  "maxPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call molded_mountainpass/amazon-keyword-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,molded_mountainpass/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/dedGBi5r6PRmLUJxe/builds/hvmjMlWpker5uh4Fy/openapi.json