# Amazon Autocomplete Scraper — Keyword Suggestions + Volume (`memo23/amazon-autocomplete-scraper`) Actor
Scrape Amazon autocomplete keyword suggestions from any seed. 16 marketplaces (US–IE), multi-department sweeps, A–Z suffix + prefix, locale-aware modifiers, question/comparison slices, filters and monitor mode — every phrase ranked by a volume-proxy score. Search URL + thumbnails. JSON or CSV.
- **URL**: https://apify.com/memo23/amazon-autocomplete-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $2.00 / 1,000 results
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 Keyword Suggestions Scraper 🔎
Turn any seed keyword into hundreds of **ranked Amazon autocomplete suggestions** — the exact phrases real shoppers see when they start typing in the Amazon search bar. Built for listing SEO, PPC research, niche discovery, and ecommerce content planning.
Most "autocomplete dumps" hand you an unsorted list. This actor adds the things that make it a real keyword tool:
- 📊 **Volume proxy** — a relative popularity score for every phrase (how many query variants surfaced it).
- 🏬 **Multi-department sweeps** — what shoppers type inside Books differs from Electronics; sweep one or many of 25+ departments in the same run.
- 🌍 **16 marketplaces** — US, UK, DE, FR, IT, ES, CA, MX, AU, JP, IN, BR, NL, AE, SA, IE — each served by its own completion service (no proxy tricks needed).
- 🌳 **Recursive keyword trees** — feed suggestions back in as seeds to mine the long tail several levels deep.
- 🔎 **Prefix, question, comparison, and localized modifier expansion** — `"a coffee grinder"` is a different list from `"coffee grinder a"`; DE gets `günstig`, not `cheap`.
> Pure HTTP. No login, no API key, no browser, no CAPTCHA solver.
> Same engine as [`amazon-keywords-scraper`](https://apify.com/memo23/amazon-keywords-scraper). This listing exists so Store search for “amazon autocomplete” hits the clean slug.
***
### Why use this scraper?
- **Find what shoppers actually type** — autocomplete is Amazon telling you, in its own words, what its customers search for.
- **Rank by popularity, not just A–Z** — the volume proxy floats in-demand phrases to the top instead of dumping an unsorted list.
- **Scale one seed into hundreds** — A–Z suffix + prefix, 0–9, locale-aware buyer modifiers, question / comparison / preposition slices, custom suffixes, and recursive depth.
- **Compare marketplaces side by side** — the same seed swept across the US, Germany, and Japan reveals how search wording changes per market.
- **See what Amazon pairs with each phrase** — source rank, ranking strategy, and the product thumbnail Amazon shows next to the suggestion.
- **Cheap and fast** — a light public endpoint, fetched in parallel. Billed per suggestion.
***
### Overview
The actor outputs **one row per suggestion** (not one row per seed). Each row carries the phrase plus its ranking signals — volume proxy, Amazon's own slot position, marketplace, department, thumbnail, and the recursion depth it was found at. Run it with a single seed for a quick autocomplete pull, or with expansion toggles + recursion across multiple marketplaces for an exhaustive keyword map.
***
### Supported inputs
| You provide | The actor does |
|---|---|
| One or more **seed keywords** | Fetches Amazon autocomplete suggestions for each |
| **Marketplaces** (16 codes, including NL / AE / SA / IE) | Sweeps each marketplace's own completion service |
| One or more **departments** (Books, Electronics, Fashion, …) | Scopes suggestions to those departments |
| **A–Z suffix + prefix / 0–9 / localized modifiers / questions / comparisons / prepositions** + **custom suffixes** | Builds the query variants Amazon actually completes |
| **Filters + monitor mode** | Drops junk rows; scheduled runs emit only new phrases |
| **Recursive depth** (0–3) | Feeds discovered suggestions back as new seeds → keyword tree |
***
### Use cases
| Audience | What they get |
|---|---|
| Amazon sellers & FBA | The exact phrases for listing titles, bullets, and backend search terms |
| PPC / Amazon Ads teams | Demand language for Sponsored Products campaigns and negative-keyword mining |
| Product researchers | Niche and long-tail discovery before committing to a product |
| Multi-market brands | Side-by-side search wording across US / EU / JP / LATAM marketplaces |
| Tool & dashboard builders | A cheap, fast suggestion feed to power your own product |
***
### How it works
1. Each seed is expanded into a set of query variants (the seed itself, plus optional A–Z suffix/prefix, 0–9, locale-aware modifiers, question/comparison/preposition slices, and custom suffixes), multiplied across the marketplaces and departments you ask for.
2. All variants are fetched **in parallel** against Amazon's public completion service (`completion.amazon.*/api/2017/suggestions`).
3. Every returned phrase is aggregated: identical suggestions are merged, and a **volume proxy** counts how many distinct variants surfaced each — a relative popularity signal.
4. If recursive depth > 0, the discovered suggestions become the next round of seeds (bounded by a request budget).
5. Results are ranked per seed and marketplace (volume proxy, then Amazon's own slot) and written one row per suggestion.
> **Note on marketplaces:** Amazon's completion service selects the marketplace via a query parameter, not by your IP — so per-country results are genuine without any proxy setup. That's different from most platforms.
***
### Input configuration
| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string\[] | — (required) | Seed terms to get suggestions for |
| `marketplaces` | string\[] | `["US"]` | Any of US, UK, DE, FR, IT, ES, CA, MX, AU, JP, IN, BR, NL, AE, SA, IE |
| `departments` | string\[] | `["aps"]` | Department aliases to sweep; `aps` = All departments |
| `expandAlphabet` | boolean | `false` | Append a–z to each seed |
| `expandPrefixAlphabet` | boolean | `false` | Prepend a–z to each seed |
| `expandNumbers` | boolean | `false` | Append 0–9 to each seed |
| `expandBuyerModifiers` | boolean | `false` | Locale-aware buyer modifiers (cheap / günstig / 安い …) |
| `expandQuestions` | boolean | `false` | Prepend how to / what is / wie / cómo … |
| `expandComparisons` | boolean | `false` | Append vs / or / oder … |
| `expandPrepositions` | boolean | `false` | Append with / without / für / sans … |
| `customSuffixes` | string\[] | `[]` | Your own suffixes, e.g. "under 50", "stainless steel" |
| `expansionDepth` | integer | `0` | Recursively re-seed from discovered suggestions (0–3) |
| `resultOrder` | string | `"volume"` | `volume` or `alphabetical` |
| `mustContainSeed` | boolean | `false` | Drop suggestions that do not contain the seed |
| `mustIncludeTerms` | string\[] | `[]` | Keep only suggestions containing at least one of these terms |
| `excludeTerms` | string\[] | `[]` | Drop suggestions containing these substrings |
| `onlyQuestions` / `onlyLongTail` | boolean | `false` | Keep questions only / 3+ word phrases only |
| `minWordCount` | integer | `0` | Drop suggestions shorter than this many words |
| `monitorMode` / `monitorKey` | boolean / string | off / `default` | Emit only phrases not seen in a previous run |
| `maxSuggestionsPerKeyword` | integer | `0` | Cap per seed per marketplace × department (0 = no cap) |
| `maxItems` | integer | `1000` | Hard cap on total rows (charging-aware) |
| `deduplicateSuggestions` | boolean | `false` | Collapse the same phrase across seeds/marketplaces into one row |
| `includeMetadata` | boolean | `true` | Include refTag, strategy id, thumbnail URL, ghost flag |
| `maxConcurrency` | integer | `10` | Simultaneous requests |
| `requestDelayMs` | integer | `0` | Optional pause after each request (ms) |
| `proxy` | object | off | Optional; not required for correct per-marketplace results |
#### Example input
```json
{
"keywords": ["laptop stand", "coffee grinder"],
"marketplaces": ["US", "DE"],
"departments": ["aps"],
"expandBuyerModifiers": true,
"expandQuestions": true,
"expansionDepth": 0,
"maxItems": 1000
}
```
***
### Output overview
Every row is a single suggestion with its ranking signals. Rows are ordered by `rank` within each (`seedKeyword`, `marketplace`) pair (1 = most popular by volume proxy). Export as JSON, CSV, Excel, or pull via the Apify API.
#### Output sample
```json
{
"suggestion": "laptop stand portable foldable travel",
"seedKeyword": "laptop stand",
"query": "laptop stand portable",
"marketplace": "US",
"domain": "amazon.com",
"department": "aps",
"rank": 1,
"volumeProxy": 2,
"amazonRank": 2,
"depth": 0,
"surfacedByQueries": ["laptop stand portable", "laptop stand for travel"],
"refTag": "nb_sb_ss_p13n-expert-pd-ops-ranker_ci_hl-bn-left_2_21",
"strategyId": "p13n-expert-pd-ops-ranker",
"thumbnailUrl": "https://m.media-amazon.com/images/I/41cMBeetqaL.__AC_SL75__.jpg",
"isGhost": false,
"searchUrl": "https://www.amazon.com/s?k=laptop%20stand%20portable%20foldable%20travel",
"wordCount": 5,
"isQuestion": false,
"scrapedAt": "2026-07-22T20:05:06.094Z"
}
```
#### Key output fields
| Field | Meaning |
|---|---|
| `suggestion` | The autocomplete phrase Amazon serves |
| `seedKeyword` | The seed it derives from |
| `query` | The exact query variant that surfaced it |
| `marketplace` / `domain` | Where it was found (US → amazon.com, DE → amazon.de, …) |
| `department` | Department scope it was fetched under |
| `rank` | Rank within its seed + marketplace (1 = top), by volume proxy |
| `volumeProxy` | How many query variants surfaced this phrase — relative popularity |
| `amazonRank` | The slot Amazon itself served it at (lower = more prominent) |
| `depth` | Recursion depth it was found at (0 = direct seed) |
| `thumbnailUrl` | Product image Amazon pairs with the phrase, when present |
| `searchUrl` | Amazon search-results URL for the phrase |
| `wordCount` / `isQuestion` | Derived shape of the phrase |
| `scrapedAt` | ISO timestamp |
***
### FAQ
**Does this need an Amazon login, API key, or token?**
No. It uses Amazon's public search-completion endpoint over plain HTTP.
**Is `volumeProxy` an exact search volume?**
No — it's a *relative* popularity signal (how many query variants surfaced the phrase). It's excellent for ranking ideas against each other, not a substitute for paid search-volume data.
**Do I need a proxy for other marketplaces?**
No. The marketplace is selected by a query parameter, so a run from anywhere returns genuine amazon.de, amazon.co.jp, etc. results.
**How many suggestions per query?**
Amazon returns up to ~10 per query. With A–Z expansion that becomes hundreds of long-tail ideas per seed; buyer modifiers, custom suffixes, and recursion deepen it further.
**Does it scrape products, reviews, or search volume?**
No — this actor is focused on autocomplete keyword suggestions. Pair it with a product or reviews scraper if you need listing data.
**Will huge expansions run forever?**
No. A built-in request budget caps total fetches and logs when it truncates, so an A–Z + deep-recursion run stays bounded.
**How does monitor mode work?**
Turn `monitorMode` on and optionally set `monitorKey`. The actor stores seen phrases in a named key-value store and, on later runs with the same key, emits only new suggestions. Use this on a schedule to watch autocomplete drift.
***
### Support
Questions, custom fields, or a tailored scraper? Email **muhamed.didovic@gmail.com** or open an issue on the actor's Issues tab. Issues are monitored and usually answered within a day.
***
### Additional services
Need this wired into a pipeline — scheduled runs, a webhook into your CRM/warehouse, a custom-shaped dataset, or a different platform's autocomplete? I build and maintain bespoke scrapers. Reach out at **muhamed.didovic@gmail.com**.
***
### Explore more scrapers
Browse the rest of the portfolio (Etsy, Amazon Sellers, TikTok Suggestions, Glassdoor, Trustpilot, and more) on the author's Apify page: **https://apify.com/memo23**
***
### 🤖 For AI Agents & LLM Apps
This actor is a clean keyword-research tool for agentic workflows: call it via the Apify API or MCP with a seed list and it returns structured, ranked keyword rows (`suggestion`, `volumeProxy`, `amazonRank`, `marketplace`) ready for downstream reasoning — listing optimization, ad-group generation, or market comparison. Deterministic input schema, per-item pricing, no session state.
***
### ⚠️ Disclaimer
This Actor collects **publicly available** Amazon search-autocomplete data for legitimate research, SEO, and market-analysis purposes. It does not log in, bypass authentication, or access private or personal data. Use of this Actor must comply with Amazon's Terms of Service and all applicable laws including data-protection regulations (GDPR, CCPA, etc.). The Actor's authors are not responsible for any misuse. Users must:
- Respect rate limits and avoid overloading Amazon's infrastructure
- Not use scraped data to violate user privacy or terms
- Use the data in compliance with applicable jurisdictions
- Not republish scraped content in violation of copyright
We do not store any scraped data; the Actor returns it directly to your Apify dataset for your authorized use. Amazon is a trademark of its respective owner; this Actor is not affiliated with, endorsed by, or sponsored by Amazon.com, Inc.
***
### SEO Keywords
amazon keyword tool, amazon search suggestions, amazon autocomplete scraper, amazon seo keywords, amazon keyword research, amazon ppc keywords, amazon listing optimization, amazon long-tail keywords, amazon search api, amazon keyword discovery, amazon fba keyword research, amazon backend search terms, ecommerce keyword research, amazon suggest scraper, amazon autocomplete api, keyword suggestions scraper, amazon marketplace keywords, amazon niche research, apify amazon scraper, amazon json csv export
# Actor input Schema
## `keywords` (type: `array`):
One or more seed terms to fetch Amazon autocomplete suggestions for. Each seed is expanded into long-tail suggestions ranked by a relative volume proxy.
## `marketplaces` (type: `array`):
Amazon marketplaces to sweep: US, UK, DE, FR, IT, ES, CA, MX, AU, JP, IN, BR, NL, AE, SA, IE. Suggestions come from the marketplace's own completion service (no proxy needed for correct per-country results). Defaults to \["US"].
## `departments` (type: `array`):
Scope suggestions to one or more Amazon departments. What shoppers type inside Books differs from Electronics. Leave as All departments unless you want a scoped sweep.
## `expandAlphabet` (type: `boolean`):
Append every letter a–z to each seed ("coffee grinder a", "coffee grinder b", …). Multiplies the request count ~26×.
## `expandPrefixAlphabet` (type: `boolean`):
Prepend every letter a–z to each seed ("a coffee grinder", "b coffee grinder", …). Amazon matches the typed prefix, so this list barely overlaps the suffix expansion.
## `expandNumbers` (type: `boolean`):
Append every digit 0–9 to each seed. Useful for sized or versioned terms ("iphone 15", "size 8").
## `expandBuyerModifiers` (type: `boolean`):
Append locale-aware buyer-intent modifiers. US gets best/cheap/for kids; DE gets günstig/für kinder; JP gets 安い/ギフト — and so on per marketplace.
## `expandQuestions` (type: `boolean`):
Prepend question stems (how to, what is, why, where to buy — plus localized stems such as wie, comment, cómo).
## `expandComparisons` (type: `boolean`):
Append comparison stems (vs, versus, or — plus localized oder/ou/o).
## `expandPrepositions` (type: `boolean`):
Append prepositions (with, without, for, under, over — plus localized mit/ohne, avec/sans, con/sin).
## `customSuffixes` (type: `array`):
Your own suffixes to append to each seed, e.g. "under 50", "stainless steel", "prime". Combined with the toggles above.
## `expansionDepth` (type: `integer`):
Feed returned suggestions back in as new seeds, building a keyword tree. 0 = seeds only (default). 1–2 recommended; higher values grow the request count quickly.
## `resultOrder` (type: `string`):
How suggestions are ranked within each seed × marketplace × department group.
## `mustContainSeed` (type: `boolean`):
Drop suggestions that drifted away from the seed phrase entirely.
## `mustIncludeTerms` (type: `array`):
Keep only suggestions containing at least one of these words or phrases (case-insensitive).
## `excludeTerms` (type: `array`):
Drop any suggestion containing one of these substrings. Case-insensitive.
## `onlyQuestions` (type: `boolean`):
Keep only question-shaped suggestions (how/what/why… or containing ?).
## `onlyLongTail` (type: `boolean`):
Keep only suggestions of three or more words.
## `minWordCount` (type: `integer`):
Drop suggestions shorter than this many words. 0 = no minimum.
## `monitorMode` (type: `boolean`):
Remember suggestions from previous runs (in a named key-value store) and return ONLY phrases not seen before. Use this on a schedule to watch autocomplete drift.
## `monitorKey` (type: `string`):
Names the monitor watch-list so you can keep separate lists per topic or market. Letters, numbers and hyphens.
## `maxSuggestionsPerKeyword` (type: `integer`):
Cap on suggestions returned per seed keyword (per marketplace × department), applied after ranking. 0 = no per-seed cap.
## `maxItems` (type: `integer`):
Hard cap on the total number of suggestion rows pushed to the dataset (charging-aware).
## `deduplicateSuggestions` (type: `boolean`):
When enabled, a suggestion surfaced by multiple seeds or marketplaces collapses into one row (volume proxy summed). When disabled (default), one row per (seed, marketplace, department, suggestion) keeps full attribution.
## `includeMetadata` (type: `boolean`):
Include Amazon's raw per-suggestion signals: refTag, ranking strategy id, product thumbnail URL, and ghost flag.
## `maxConcurrency` (type: `integer`):
Maximum simultaneous requests to Amazon's completion service. The endpoint is light, so 10–20 is safe.
## `requestDelayMs` (type: `integer`):
Optional pause after each autocomplete request. Raise this for very large jobs if Amazon starts returning empty bodies.
## `proxy` (type: `object`):
Leave empty — the endpoint is public and marketplace selection happens via a query parameter, so no proxy is required. Paying users are auto-routed through built-in residential proxies for resilience at high volume.
## Actor input object example
```json
{
"keywords": [
"laptop stand",
"coffee grinder"
],
"marketplaces": [
"US"
],
"departments": [
"aps"
],
"expandAlphabet": false,
"expandPrefixAlphabet": false,
"expandNumbers": false,
"expandBuyerModifiers": false,
"expandQuestions": false,
"expandComparisons": false,
"expandPrepositions": false,
"expansionDepth": 0,
"resultOrder": "volume",
"mustContainSeed": false,
"onlyQuestions": false,
"onlyLongTail": false,
"minWordCount": 0,
"monitorMode": false,
"monitorKey": "default",
"maxSuggestionsPerKeyword": 0,
"maxItems": 1000,
"deduplicateSuggestions": false,
"includeMetadata": true,
"maxConcurrency": 10,
"requestDelayMs": 0
}
```
# Actor output Schema
## `results` (type: `string`):
No description
## `csv` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"laptop stand",
"coffee grinder"
],
"marketplaces": [
"US"
],
"departments": [
"aps"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("memo23/amazon-autocomplete-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": [
"laptop stand",
"coffee grinder",
],
"marketplaces": ["US"],
"departments": ["aps"],
}
# Run the Actor and wait for it to finish
run = client.actor("memo23/amazon-autocomplete-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": [
"laptop stand",
"coffee grinder"
],
"marketplaces": [
"US"
],
"departments": [
"aps"
]
}' |
apify call memo23/amazon-autocomplete-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/amazon-autocomplete-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 ` 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/7fSegkI3QF8qSRu3S/builds/90igNT9JhCEtdiUZt/openapi.json