# Amazon Keyword Research Tool (`dami_studio/amazon-keyword-research-scraper`) Actor

Amazon keyword research tool: look up keywords and get what the results page shows for each: the result count, first-page prices, ratings, reviews, sponsored share and bought-past-month totals. Track where your ASINs rank, or run a reverse ASIN lookup for the keywords a product shows up for.

- **URL**: https://apify.com/dami_studio/amazon-keyword-research-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.16 / 1,000 keywords

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 keyword research tool, from Amazon's own results page**: give it keywords, ASINs or both, and each keyword comes back as one row with the result count Amazon prints, the first page's prices, ratings, reviews, sponsored share and bought-past-month total, plus where your products rank on it. Turn on reverse ASIN and it builds the keywords for a product from its own title and Amazon's suggestions, then checks each one.

The part to know before you plan around it: the numbers are what Amazon showed this run, on the first page of results, to a shopper who is not signed in. Rankings move during the day, so a rank tracker needs a schedule, not one run.

| | |
|---|---|
| **Input** | Keywords, ASINs or product links, and the Amazon store to look them up on |
| **Output** | One row per keyword: result count, products on page 1, sponsored count, price range and median, average rating, review counts, bought-past-month total, badges, the first products, and your products' organic and sponsored ranks |
| **Ceiling** | 5,000 keyword rows per run; up to 100 products and 200 keywords per product in reverse ASIN |
| **Speed** | Roughly 15 to 20 keywords a minute |
| **Account needed** | None |
| **Price** | $0.16 per 1,000 keywords, the same on every plan. The free plan's $5 a month covers about 31,000. Search volumes and full keyword lists are paid extras, off unless you turn them on |

### 🔍 What Amazon Keyword Research Tool does

It looks each keyword up on the Amazon store you pick and reads the first page of results the way a shopper sees it. From that page it works out the market numbers for the keyword: how many results Amazon says there are, how many products on the page are ads, what they cost, how they are rated and how much they sell.

Three ways to use it:

- **Keyword research.** Paste keywords. Turn on Amazon's suggestions to grow the list with what shoppers type, with a to z, 0 to 9, buyer words or your own endings.
- **Rank tracking.** Add your ASINs. Every keyword row says where each one sits on page 1, organic and sponsored, or that it is not there.
- **Reverse ASIN.** Give it another seller's ASIN. It reads the product's title, builds keywords from it and from Amazon's suggestions, and checks each one, so you see which searches the product shows up for and where.

### 📋 What data you get from each Amazon keyword

| What | Fields |
|---|---|
| The keyword | `keyword`, `marketplace`, `department`, `language`, `source`, `seedKeyword`, `expansionType`, `expansion`, `suggestionRank`, `suggestionImage` |
| Amazon's result count | `resultCount`, `resultCountText`, `resultCountIsMinimum`, `amazonSearchedFor` |
| Page 1 at a glance | `productsOnPage`, `organicOnPage`, `sponsoredOnPage`, `sponsoredShare`, `adSlotsOnPage` |
| Prices | `priceMin`, `priceMax`, `priceMedian`, `priceAverage`, `currency` |
| Ratings and reviews | `ratingAverage`, `reviewsMedian`, `reviewsTotal`, `productsUnder100Reviews` |
| Sales signals | `boughtPastMonthTotal`, `productsWithBoughtPastMonth`, `bestSellerOnPage`, `amazonsChoiceOnPage`, `couponOnPage` |
| The first products | `topProducts`: position, organic or sponsored rank, ASIN, title, price, rating, reviews, bought past month, badges, coupon, delivery line, link, image |
| Your products | `asinRanks`: found, organic rank, sponsored rank, position, title, price, rating, reviews |
| Reverse ASIN | `asin`, `asinTitle`, `asinFound`, `asinOrganicRank`, `asinSponsoredRank`, `asinPosition` |
| Monthly search volume (paid extra) | `searchVolume` on each keyword row |
| A product's full keyword list (paid extra) | rows with `source` "ranked list": `keyword`, `searchVolume`, `keywordUpdated`, `resultCount`, `asinOrganicRank`, `asinSponsoredRank`, `asinPosition`, `product` |

### ▶️ How to scrape Amazon keyword data

1. Open [Amazon Keyword Research Tool](https://apify.com/dami_studio/amazon-keyword-research-scraper) on Apify and click **Try for free**.
2. Type your keywords into **Keywords**, one per line.
3. Pick the store under **Amazon stores**. amazon.com is set by default.
4. Optional: add ASINs under **Products to track**, and tick **Find the keywords these products show up for** for reverse ASIN.
5. Click **Start**, then open the **Output** tab or export the dataset as CSV, Excel or JSON.

Run it with nothing filled in and you get one free sample row that shows the shape of the output.

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

**$0.16 per 1,000 keywords**, the same on every Apify plan. On the free plan, the $5 Apify gives you each month covers about 31,000 keywords.

One keyword row is one charge, whichever way the keyword got there: typed in, found in Amazon's suggestions, or built for reverse ASIN. A keyword checked for two of your products in reverse ASIN is two rows. Looking up Amazon's suggestions costs nothing, and neither does reading a product's title for reverse ASIN. Sample rows and note rows are never charged.

The two paid extras are charged only when you turn them on. Search volumes: $0.70 per 1,000 keywords that get one, plus $0.015 for each request, which covers a store's keywords 1,000 at a time. A product's full keyword list: $0.16 per 1,000 rows, plus $0.025 for each product looked up, even one with no keywords. A run asks only for what your spending limit can still pay for.

### 📥 What you give it

| Field | What it does | Default |
|---|---|---|
| `keywords` | Keywords to look up, up to 1,000 | none |
| `asins` | ASINs or product links to find on every keyword's first page, up to 100 | none |
| `findKeywordsForAsins` | Reverse ASIN: build and check keywords for each product | `false` |
| `keywordsPerAsin` | Keywords checked per product in reverse ASIN, and rows per product in a full keyword list, 1 to 200 | `30` |
| `includeSearchVolume` | Monthly search volume on each keyword row (amazon.com, .ca, .com.mx, .nl, .ae, .sa, .eg, .in), a paid extra | `false` |
| `fullKeywordListForAsins` | Each product's keywords, best rank first (amazon.com, .eg, .sa, .ae), a paid extra | `false` |
| `addSuggestions` | Also look up Amazon's suggestions for each keyword | `false` |
| `expandAlphabet` | Suggestions after the keyword plus a to z | `false` |
| `expandNumbers` | Suggestions after the keyword plus 0 to 9 | `false` |
| `expandModifiers` | Suggestions with buyer words (best, cheap, for women...) in the store's language | `false` |
| `customSuffixes` | Your own endings to ask suggestions for, up to 50 | none |
| `suggestionsPerLookup` | Suggestions kept per lookup, 1 to 10 | `10` |
| `marketplaces` | Amazon stores: amazon.com, .ca, .com.mx, .com.br, .ie, .de, .nl, .com.be, .se, .pl, .com.tr, .ae, .sa, .eg, .in, .co.jp, .com.au, .sg | `["com"]` |
| `department` | Search inside one department, such as `electronics` or `stripbooks`; empty for all | empty |
| `language` | Page language where the store offers it, such as `es_US` on amazon.com | the store's own |
| `topProducts` | First-page products listed in each row, 0 to 60 | `10` |
| `maxKeywords` | The run stops after this many keyword rows, 1 to 5,000 | `100` |
| `delayBetweenLookupsMs` | Extra pause between results pages | `0` |
| `maxConcurrency` | Results pages read at once, 1 to 3 | `2` |

```json
{
  "keywords": ["coffee grinder", "burr grinder"],
  "asins": ["B005EPRFKO"],
  "findKeywordsForAsins": true,
  "keywordsPerAsin": 10,
  "marketplaces": ["com"],
  "topProducts": 3
}
```

### 📤 What you get back

A real reverse ASIN row from a run on 3 November 2026, with `topProducts` cut to one product:

```json
{
  "recordType": "keyword",
  "keyword": "electric coffee grinder",
  "marketplace": "amazon.com",
  "source": "product title",
  "resultCount": 3000,
  "resultCountText": "1-48 of over 3,000 results for",
  "resultCountIsMinimum": true,
  "productsOnPage": 48,
  "sponsoredOnPage": 0,
  "priceMin": 13.38,
  "priceMax": 399.95,
  "priceMedian": 39.17,
  "ratingAverage": 4.34,
  "reviewsMedian": 1602,
  "boughtPastMonthTotal": 109150,
  "amazonsChoiceOnPage": 1,
  "currency": "USD",
  "topProducts": [
    {
      "position": 1,
      "organicRank": 1,
      "sponsored": false,
      "asin": "B005EPRFKO",
      "title": "Hamilton Beach Fresh Grind Electric Coffee Grinder For Up To 12 Cups",
      "priceValue": 20.87,
      "rating": 4.5,
      "reviews": 64328,
      "boughtPastMonth": 10000,
      "badges": ["Amazon's Choice", "Overall Pick"]
    }
  ],
  "asin": "B005EPRFKO",
  "asinFound": true,
  "asinOrganicRank": 1,
  "asinSponsoredRank": null,
  "asinPosition": 1,
  "searchUrl": "https://www.amazon.com/s?k=electric+coffee+grinder"
}
```

| Field | How to read it |
|---|---|
| `resultCount` | The total Amazon prints. With `resultCountIsMinimum: true` Amazon said "over", so it is a floor |
| `amazonSearchedFor` | Set when Amazon searched for a different spelling than yours; the row's numbers are for that search |
| `boughtPastMonthTotal` | The sum of Amazon's "bought in past month" labels on page 1, each read as the floor it states (10K+ is 10,000) |
| `organicRank` and `sponsoredRank` | Counted separately: the third ad and the third organic result can sit next to each other |
| `position` | Place among every product card on the page, ads included |
| Prices | Numbers in the store's own currency; empty when a card shows no price |

### 🧾 Reading the output

- **Keyword rows** have `recordType: "keyword"`. These are the ones you pay for.
- **The free sample row** has `_sample: true` and appears only when the input is empty.
- **Note rows** have `_diagnostic: true` and `ok: false`, are never charged, and carry an `errorCode`:

| Code | What happened |
|---|---|
| `BAD_INPUT` | Something in the input could not be used; `details` says what. Nothing was looked up |
| `NOT_SERVED` | This keyword, this product's title, or the search volumes or keyword lists, were not served this run. Re-run it later |
| `NOT_FOUND` | A product given for reverse ASIN was not found on that store |
| `TIME_LIMIT` | The run's time limit stopped it; `keywordsLeft` says how many were not looked up |
| `COST_LIMIT` | The maximum cost you set stopped it before the rest |
| `SETUP` | A problem on our side stopped the run before any lookup, or kept the paid extras out of it. Nothing was charged for what didn't come |
| `UNEXPECTED_ERROR` | The run stopped early on an unexpected error. Rows before it are kept |

To keep only keyword rows, filter on `recordType` equal to `keyword`. For reverse ASIN, `asinFound: true` gives you the keywords the product shows up for on page 1.

### 💡 What people use it for

- Choosing a product idea by comparing how crowded each keyword is: result counts, median reviews and how many page-1 products sit under 100 reviews.
- Writing a listing title and bullets from the searches shoppers really type, found through Amazon's suggestions.
- Checking every morning where your ASINs rank for your 50 main keywords, organic and sponsored.
- Seeing which searches another seller's product shows up for, before you build a PPC campaign around them.

A recipe with three steps: run this with reverse ASIN on another seller's ASIN; keep the rows where `asinFound` is true and `asinOrganicRank` is under 10; send those keywords back into this actor with your own ASIN under **Products to track** and schedule it daily.

### 🚧 What it does not do

- It reads the public store. It never signs in to a seller or advertising account, so there are no conversion rates, click shares or ad bids.
- It keeps no history. Each run reads the pages as they are at that moment; schedule it to follow a product over time.
- Bought-past-month figures are Amazon's own labels, read as the floor they state. They are not a sales model.
- It is not an official Amazon tool. Dami's Studio is independent and is not affiliated with or endorsed by Amazon, or by any other company named on this page.

### 🧭 Which Amazon scraper do you need?

| If you want | Use |
|---|---|
| Keyword numbers, rank tracking and reverse ASIN on Amazon | This one |
| Full product details by ASIN, link or keyword: price, Best Sellers Rank, seller, variants | [Amazon Scraper](https://apify.com/dami_studio/amazon-scraper) |
| The reviews on a product page, one row each | [Amazon Reviews Scraper](https://apify.com/dami_studio/amazon-reviews-scraper) |
| A category's Best Sellers or New Releases list | [Amazon Bestsellers Scraper](https://apify.com/dami_studio/amazon-bestsellers-scraper) |
| Just the search-box suggestions, for Amazon or the big web search engines | [Keyword Autocomplete Scraper](https://apify.com/dami_studio/keyword-autocomplete-scraper) |

### ❓ Questions people ask

#### Do I need an Amazon account to research keywords?

No. The run reads Amazon's public results pages the way a shopper who is not signed in sees them, and you give it nothing to log in with.

#### Why don't the numbers match what I see on Amazon?

Amazon changes the page by delivery location, sign-in, browsing history and the time of day, and it rounds big result counts ("over 10,000"). To compare, open the row's `searchUrl` in a private window on the same store.

#### How does reverse ASIN choose the keywords?

It takes the phrases that name the product in its title, such as "electric coffee grinder", asks Amazon's suggestions for them, and checks each keyword in that order until it reaches `keywordsPerAsin`. Every keyword checked comes back as a row, found or not.

#### Can I run it from code or an AI assistant?

Yes. The [API tab](https://apify.com/dami_studio/amazon-keyword-research-scraper/api/python) has ready code for Python, JavaScript and HTTP. For an AI assistant, connect Apify's MCP server at `https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/amazon-keyword-research-scraper`. Set `maxTotalChargeUsd` on the run to cap what it can spend.

#### Is scraping Amazon legal?

This reads public results pages, the same ones any shopper sees, with no account. The rows hold product listings and counts rather than data about people, so there is little personal data to look after; keep only what you need all the same. Amazon's own terms still apply to what you do with the data. Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a good starting point, and we are not lawyers.

### 🆘 If something breaks

Open the **Issues** tab on the actor page. Send the keyword, the store and the run ID; the note rows usually say what happened.

# Actor input Schema

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

Each keyword is looked up on Amazon's results page and comes back as one row: the result count, the first page's prices, ratings, reviews, sponsored share and bought-past-month totals, and the first products. Up to 1,000 a run.

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

Every keyword row says where each of these products sits on that keyword's first page of results: its organic rank, its sponsored rank, or not found. Turn on the reverse ASIN option below to have the run find keywords for them too. Up to 100.

## `findKeywordsForAsins` (type: `boolean`):

For each product, the run reads its title, builds keywords from it and from Amazon's suggestions for its main phrases, and checks each one. Every keyword checked is a row, with asinFound true or false.

## `keywordsPerAsin` (type: `integer`):

How many keywords the reverse ASIN option checks for each product. Each one checked is a row.

## `includeSearchVolume` (type: `boolean`):

Adds searchVolume, how many times a month shoppers search Amazon for the keyword, to each keyword row on amazon.com, .ca, .com.mx, .nl, .ae, .sa, .eg and .in. Each volume added is charged, and so is each request for them: one per store per 1,000 keywords.

## `fullKeywordListForAsins` (type: `boolean`):

For each product in "ASINs", adds the keywords it ranks for, best rank first, one row each with its monthly search volume and the product's rank, up to "Keywords to check per product". On amazon.com, .eg, .sa and .ae. Each row is charged, and so is each product's list, even one with no keywords.

## `addSuggestions` (type: `boolean`):

Look up the phrases Amazon suggests in its search box for each of your keywords too. Each one becomes its own row.

## `expandAlphabet` (type: `boolean`):

Asks Amazon for suggestions after "keyword a", "keyword b" and so on, which brings out the long tail.

## `expandNumbers` (type: `boolean`):

Asks for suggestions after "keyword 0" to "keyword 9": sizes, pack counts and model numbers.

## `expandModifiers` (type: `boolean`):

Asks for suggestions with buying words around the keyword, in the store's language: best, cheap, for women, for men, for kids, small, large, set, gift and a few more.

## `customSuffixes` (type: `array`):

Words to put after each keyword before asking for suggestions, for example "for dogs" or "stainless steel". Up to 50.

## `suggestionsPerLookup` (type: `integer`):

Amazon shows up to 10 suggestions for each thing typed. Keep fewer to stay with the most searched ones.

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

Which Amazon store to look the keywords up on. Pick several to compare stores in one run; each keyword in each store is a row.

## `department` (type: `string`):

Optional. Search inside one department, as Amazon names it in its search links: electronics, stripbooks, grocery, toys-and-games, beauty, fashion and so on. Leave empty for all departments.

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

Optional. Ask the store for its pages in this language where it offers it, for example Spanish on amazon.com. Leave empty for the store's own language.

## `topProducts` (type: `integer`):

How many of the first page's products to include in each row, with their rank, price, rating, reviews and badges. 0 leaves the list out; the page numbers are counted over every product either way.

## `maxKeywords` (type: `integer`):

The run stops after this many keyword rows, across every store, suggestion and product.

## `delayBetweenLookupsMs` (type: `integer`):

Optional. Slows the run down by this much between results pages.

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

How many results pages the run reads at the same time.

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

Optional. Leave this alone unless you need the run to go out through your own proxy servers; those are tried first.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "findKeywordsForAsins": false,
  "keywordsPerAsin": 30,
  "includeSearchVolume": false,
  "fullKeywordListForAsins": false,
  "addSuggestions": false,
  "expandAlphabet": false,
  "expandNumbers": false,
  "expandModifiers": false,
  "suggestionsPerLookup": 10,
  "marketplaces": [
    "com"
  ],
  "topProducts": 10,
  "maxKeywords": 100,
  "delayBetweenLookupsMs": 0,
  "maxConcurrency": 2
}
```

# Actor output Schema

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

One row per keyword looked up: the result count, the first page's market numbers, the first products and where your tracked products rank. Free note rows say what happened to anything that did not become a row.

## `report` (type: `string`):

Keywords delivered, keywords not served, products not found, suggestion lookups and why the run stopped.

# 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": [
        "coffee grinder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/amazon-keyword-research-scraper").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": ["coffee grinder"] }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/amazon-keyword-research-scraper").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": [
    "coffee grinder"
  ]
}' |
apify call dami_studio/amazon-keyword-research-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/amazon-keyword-research-scraper"
        }
    }
}
```

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/WTlT3ra39WQ2MgkJH/builds/xbFTNf2AZgPLaOtDe/openapi.json
