# Keyword Autocomplete Scraper (`dami_studio/keyword-autocomplete-scraper`) Actor

Keyword autocomplete scraper: the suggestions Google, YouTube, Amazon and Bing show for your seed keywords, by country and language. One row per suggestion with its rank and the text looked up. Add a to z, 0 to 9 or question words for longer phrases. $0.01 to $0.35 per 1,000 suggestions, by engine.

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

## Pricing

from $0.05 / 1,000 google suggestions

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

**Keyword autocomplete scraper for a seed keyword, what four search boxes suggest as you type it**: the completions from
`google`, `youtube`, `amazon` and `bing`, in the country and language you pick, one row per
suggestion with its rank and the exact text that was typed.

Start typing "coffee grinder" and the box offers to finish it for you: for espresso, walmart, near
me. Those completions are real searches, ranked by the engine that serves them. No volumes, though. A
suggestion tells you what people type, not how many of them do, and nothing here will give you a
monthly search count or a cost per click.

| | |
|---|---|
| **Input** | Seed keywords, up to 1,000 per run |
| **Output** | One row per suggestion: the phrase, its rank, the engine and the exact text looked up |
| **Ceiling** | 50,000 suggestions per run |
| **Speed** | 1,776 suggestions from one seed in about 14 seconds; 50,000 in under 6 minutes |
| **Account needed** | None, and no API key |
| **Price** | On the Free plan, $0.0103 per 1,000 `amazon` suggestions, $0.047 per 1,000 from `google`, $0.095 from `youtube` and $0.35 from `bing`; paid plans pay a little less. The free plan's $5 a month covers about 485,000 `amazon` suggestions, or about 106,000 from `google` |

### 🔍 What Keyword Autocomplete Scraper does

It asks each engine for the list its search box shows while you type, and writes down what comes
back in order. Every row names the engine it came from, so a phrase two engines both suggest arrives
twice, once each, and you can see which of them thinks it matters.

The variations are where the long phrases live. Switch them on and each seed is asked again with a
trailing space, with a to z on the end, with 0 to 9, and with question words in front. "coffee
grinder" with all four on came back as 1,776 different suggestions from 204 lookups across the four
engines. Set `expansionDepth` to 2 and every new suggestion is asked again as if you had typed it.

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

| What you get | Field |
|---|---|
| The suggested phrase and its place in that list | `suggestion`, `rank` |
| Which engine suggested it | `engine` |
| What you typed, and the exact text that went to the engine | `seed`, `query` |
| Which variation produced it, and the letter, digit or word | `expansionType`, `expansion` |
| How many levels deep it was found, on runs that follow suggestions | `depth` |
| The country, and the language or the market used | `country`, `language` |
| The Amazon marketplace and department, on `amazon` rows | `marketplace`, `department` |
| The Google list asked for, whether it is a search or a website, and Google's score, on `google` rows | `searchType`, `suggestionType`, `relevance` |
| When the engine answered | `scrapedAt` |

### ▶️ How to scrape keyword suggestions

1. Open [Keyword Autocomplete Scraper](https://apify.com/dami_studio/keyword-autocomplete-scraper)
   and click **Try for free**.
2. Put your keywords into **Seed keywords**, one per line.
3. Tick the engines you want, then set **Country** and **Language**.
4. Turn on **Seed followed by a to z** if you want the long tail, set **Maximum suggestions**, and
   click **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it from the Apify API.

Run it with no seeds and you get one sample row, not charged.

### 💰 How much does it cost to scrape keyword suggestions?

You pay per suggestion delivered, at the rate for the engine that produced it. Paid plans pay a
little less. Prices per 1,000 suggestions:

| Engine | Free | Starter | Scale | Business |
|---|---|---|---|---|
| `amazon` | $0.0103 | $0.0102 | $0.0101 | $0.01 |
| `google` | $0.047 | $0.0465 | $0.046 | $0.0455 |
| `youtube` | $0.095 | $0.094 | $0.093 | $0.092 |
| `bing` | $0.35 | $0.345 | $0.34 | $0.335 |

On the free plan, the $5 Apify gives you each month covers about 485,000 `amazon` suggestions, or
about 106,000 from `google`.

A lookup that comes back empty is free. So is a phrase the same engine already gave you in the run,
a lookup an engine answered for different text, and the sample row.

### 📥 What you give it

```json
{
  "seeds": ["coffee grinder", "french press"],
  "engines": ["google", "youtube", "amazon"],
  "country": "GB",
  "language": "en",
  "expandAlphabet": true,
  "expandQuestions": true,
  "maxSuggestions": 3000
}
```

| Field | Default | What it is |
|---|---|---|
| `seeds` | none, the box starts at `coffee grinder` | One per line, up to 1,000. Written the way you would start typing. Repeats are dropped. |
| `engines` | `["google"]`, the box starts at three of them | Any combination of `google`, `youtube`, `amazon` and `bing`. |
| `country` | `US` | `google` and `youtube` lean toward it. `bing` reads it together with the language. `amazon` goes by the marketplace instead. |
| `language` | `en` | The language `google` and `youtube` answer in. `amazon` ignores it. `google` has no separate suggestions in 31 of the 90 and answers them exactly as English: Afrikaans, Albanian, Armenian, Azerbaijani, Basque, Burmese, Galician, Georgian, Hausa, Irish, Javanese, Kazakh, Khmer, Kurdish, Kyrgyz, Lao, Luxembourgish, Macedonian, Maltese, Maori, Mongolian, Pashto, Sinhala, Somali, Tajik, Urdu, Uzbek, Welsh, Xhosa, Yoruba and Zulu. |
| `amazonMarketplace` | `auto` | `auto` uses the Amazon of your country, or amazon.com where that country has none. Or name one of the 23 yourself. |
| `amazonDepartment` | none | Amazon's own short name from its search links: `stripbooks`, `electronics`, `grocery`. A name Amazon does not know returns nothing at all. |
| `googleSearchType` | `web` | `web`, `shopping`, `images` or `news`. Shopping leans to products: "coffee" led with coffee table and coffee maker where web led with coffee near me. `images` and `news` come out close to `web`. |
| `addTrailingSpace` | off | Also asks "coffee grinder " with the space typed. Engines finish that differently. |
| `expandAlphabet` | off | 26 more lookups per seed and engine. Most of the long phrases come from here. |
| `expandNumbers` | off | 10 more lookups per seed and engine. Good for model numbers, sizes and years. |
| `expandQuestions` | off | One lookup per question word, in front of the seed: "how coffee grinder". |
| `questionWords` | 13 English ones | Your own list, up to 30. Add best or cheap, or words in the language you picked. |
| `expansionDepth` | `1` | `2` also asks each new suggestion as if you had typed it, and `3` goes one level further. That is where the longest phrases come from. `maxSuggestions` still stops the run. |
| `maxSuggestionsPerQuery` | none, keeps everything | Up to 15 come from `google`, 14 from `youtube`, 10 from `amazon`, 25 from `bing`. |
| `maxSuggestions` | `5000`, the box starts at `300` | Suggestions in one run, all engines together, up to 50,000. |

**If an engine has nothing for a seed, its space, letter and number variations are skipped**, since
they only make the same text longer. Question words are still asked.

### 📤 What you get back

A real row from a run on 1 October 2026 with `expansionDepth` at 2, so this suggestion came from
asking an earlier suggestion again:

```json
{
  "suggestion": "running shoes for men sale",
  "rank": 1,
  "engine": "google",
  "seed": "running shoes",
  "query": "running shoes for men",
  "expansionType": "suggestion",
  "expansion": null,
  "country": "GB",
  "language": "en",
  "marketplace": null,
  "department": null,
  "searchType": "web",
  "suggestionType": "query",
  "relevance": 601,
  "scrapedAt": "2026-10-01T00:22:44.101Z",
  "depth": 2
}
```

| Field | How to read it |
|---|---|
| `rank` | Its place in the engine's list for that one lookup, starting at 1. |
| `query` | The exact text that went to the engine. Here it is an earlier suggestion, "running shoes for men", asked again. |
| `expansionType` | `seed`, `trailing space`, `letter`, `number`, `question`, or `suggestion` when a suggestion was asked again. |
| `language` | `null` on `amazon` rows, which have no language. On `bing` rows it is the market actually used. |
| `suggestionType` | `navigation` means Google offered a website address rather than a search. `google` rows only. |
| `relevance` | Google's own score for the suggestion. `google` rows only. |

### 🧾 Reading the output

| Row | How to spot it | Charged |
|---|---|---|
| A suggestion | `_sample` is absent | yes |
| The sample row | `_sample: true` | no |

No diagnostic rows go into the dataset. The status message leads with the split, like "Returned N
suggestions for S seeds", then names any engine that stopped answering, any lookup answered for
different text, and an Amazon department that returned nothing. `RUN_REPORT` in the key-value store
has it per engine and per seed: lookups planned, made, answered, empty, skipped, repeats dropped and
rows returned.

| Note row (not charged) | What it means |
|---|---|
| `BAD_INPUT` | A value in the input is one the run refuses, so nothing was read. The run still ends as succeeded. |
| `COST_LIMIT` | The maximum cost you set for the run does not cover a single result. Raise it and run again. The run still ends as succeeded. |
| `NOT_SERVED` | The site did not answer any search in this run. Run it again later. The run still ends as succeeded. |

### 💡 What people use it for

- Building a long-tail keyword list for a page, with a to z on and the question words switched in.
- Finding the questions people actually ask about a product, straight from the question variations.
- Comparing what `amazon` completes against what `google` completes for the same seed, which is
  roughly buying intent against reading intent.
- Watching a seed week by week on a schedule and diffing on `suggestion` and `rank`.

From a seed to the pages that rank for it, in three runs:

1. Run this on a seed with `expandQuestions` on and keep the `suggestion` values worth writing about.
2. Put the best few into [Google Trends Scraper](https://apify.com/dami_studio/google-trends-scraper)'s
   `searchTerms` with `compareKeywords` on, to see which one is growing.
3. Run the winner through
   [Google Search Results Scraper](https://apify.com/dami_studio/google-search-results-scraper)'s
   `query` to see who already ranks for it.

### 🚧 What it does not do

- **No search volume, cost per click or difficulty score.** Only the suggestions and their order.
- **It is a snapshot.** Engines reshuffle through the day, so tomorrow's run will differ.
- **Nothing personalised.** The engines see a visitor with no history and no account.
- **A few local suggestions slip in.** `google` and `bing` can mix in a few place names,
  whatever country you set. In US runs that shows as names like "car insurance
  maryland". A German run checked against the same lookups matched 252 of 254.
- **`amazon` ignores the language**, and goes entirely by the marketplace.
- **`google` has no separate suggestions in some languages.** For Welsh, Irish, Urdu and 28 more,
  listed under `language` above, it gave exactly the English list in a check in September 2026.
- **`amazon` sometimes corrects your spelling** and answers the corrected phrase instead. Asked for
  "does coffee grinder" it answered for "dose coffee grinder". Those are dropped, not charged, and
  counted in the status.
- **`bing` only answers language and country pairs it runs a market for.** English in Germany is not
  one. Without a match it uses that country's own market and says so, and where it has no market at
  all it sits the run out.
- **When a limit or a budget stops a run early**, the rows you keep are whatever arrived first, not
  an even share across engines.
- It is not an official Google tool. Dami's Studio is independent and is not affiliated with or endorsed by Google, YouTube, Amazon or Microsoft, or by any other company named on this page.

### 🧭 Which search scraper do you need?

| If you want | Use |
|---|---|
| The web results page for a keyword: organic, ads, People Also Ask | [Google Search Results Scraper](https://apify.com/dami_studio/google-search-results-scraper) |
| What a search box suggests as people type | This one |
| Interest in a keyword over time and by region | [Google Trends Scraper](https://apify.com/dami_studio/google-trends-scraper) |
| News articles with the publisher's real link | [Google News Scraper](https://apify.com/dami_studio/google-news-scraper) |
| Image results and the pages they sit on | [Google Images Scraper](https://apify.com/dami_studio/google-images-scraper) |
| The ads a brand runs on Google | [Google Ads Transparency Scraper](https://apify.com/dami_studio/google-ads-transparency-scraper) |
| Yandex results by keyword and region | [Yandex Search Engine Scraper](https://apify.com/dami_studio/yandex-search-engine-scraper) |
| Autocomplete from Taobao, in Chinese | [Taobao Keyword Suggestions Scraper](https://apify.com/dami_studio/taobao-keyword-suggestions-scraper) |

### ❓ Questions people ask

#### Do I need an API key for keyword suggestions?

No. No key, no account, nothing to apply for.

#### Why fewer rows than lookups times 15?

Repeats, mostly. Many variations return phrases an earlier lookup already found, and those are not
sent twice. Short lists happen too: on amazon.com, "how coffee" returned two suggestions.

#### How do I get more phrases from one seed?

Turn on **Seed followed by a to z** first. It is the variation that adds the most, and question
words are the next best. Then set **Levels of suggestions to follow** to 2.

#### Does it work in other alphabets?

Yes. Seeds in Japanese, Korean, Russian and Hebrew came back in their own scripts. The a to z
variation adds Latin letters, which suits some writing systems more than others.

#### Can I call it from code or connect it to an AI assistant?

The [API tab](https://apify.com/dami_studio/keyword-autocomplete-scraper/api/python) has code for Python, JavaScript
and the CLI. MCP clients like Claude and ChatGPT use
`https://mcp.apify.com/?tools=fetch-actor-details,dami_studio/keyword-autocomplete-scraper`; coding assistants can
load [our skill
file](https://api.apify.com/v2/key-value-stores/BTBHU3DdiuoF4JOsK/records/apify-search-app-stores-SKILL.md). All three
bill your Apify account at the same price.

#### Is collecting search suggestions legal?

Suggestions are phrases the engines show to anyone typing into the box. 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 run ID and the seeds you used. The status message
and `RUN_REPORT` usually say which engine fell short.

# Actor input Schema

## `seeds` (type: `array`):

One per line, the way you'd start typing a search. Each seed goes to every engine you pick. Repeats are dropped. Up to 1,000 per run.

## `engines` (type: `array`):

Where to ask. Every row names its engine, and a phrase two engines both suggest comes back once for each of them.

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

Google and YouTube lean their suggestions toward this country. Bing reads it together with the language below. Amazon goes by the marketplace instead.

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

The language Google and YouTube suggest in. Google has no separate suggestions in some languages, Welsh, Irish and Urdu among them, and answers those exactly as in English; the README lists them. Bing needs a language it has a market for in that country; when it hasn't, the run uses the country's own Bing market and says so in the status. Amazon ignores this setting.

## `amazonMarketplace` (type: `string`):

Which Amazon to ask. Match the country uses the country above, or amazon.com when that country has no Amazon of its own.

## `amazonDepartment` (type: `string`):

Leave it empty for all of Amazon. Otherwise use Amazon's own short name for the department, the one in its search links: stripbooks for books, electronics, grocery. A name Amazon doesn't know gets no suggestions at all.

## `googleSearchType` (type: `string`):

Web is what the Google search box suggests. Shopping leans toward products: for "coffee" it led with coffee table and coffee maker where web led with coffee near me. Images and News come out close to Web.

## `addTrailingSpace` (type: `boolean`):

Also asks for "coffee grinder " with the space typed. Engines often complete it differently.

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

26 more lookups per seed and engine: "coffee grinder a", "coffee grinder b" and so on. Most of the long phrases come from here.

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

10 more lookups per seed and engine. Good for model numbers, sizes and years.

## `expandQuestions` (type: `boolean`):

One more lookup per question word below: "how coffee grinder", "why coffee grinder". Engines finish these as the questions people ask.

## `questionWords` (type: `array`):

Used when question words are on. Add words of your own, such as best or cheap, or words in the language you picked. Up to 30.

## `expansionDepth` (type: `integer`):

1 asks your seeds and the variations switched on above. 2 also asks each new suggestion as if you had typed it, which is where the longer phrases come from. 3 goes one level further. Every level adds lookups, and Maximum suggestions still stops the run.

## `maxSuggestionsPerQuery` (type: `integer`):

Keep only the top of each list. Leave it empty to keep all of it: up to 15 from Google, 14 from YouTube, 10 from Amazon and 25 from Bing.

## `maxSuggestions` (type: `integer`):

The most suggestions one run returns, all engines together, up to 50,000. Each one returned is one charge.

## Actor input object example

```json
{
  "seeds": [
    "coffee grinder"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ],
  "country": "US",
  "language": "en",
  "amazonMarketplace": "auto",
  "googleSearchType": "web",
  "addTrailingSpace": false,
  "expandAlphabet": false,
  "expandNumbers": false,
  "expandQuestions": false,
  "questionWords": [
    "how",
    "what",
    "why",
    "where",
    "when",
    "who",
    "which",
    "can",
    "is",
    "are",
    "does",
    "will",
    "should"
  ],
  "expansionDepth": 1,
  "maxSuggestions": 300
}
```

# Actor output Schema

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

One row per suggestion: the suggestion, its rank, the engine, the seed and the exact text looked up, the variation, and the country, language or marketplace it was asked for.

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

Lookups made and answered per engine, suggestions returned and skipped as repeats, what each seed brought back, 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 = {
    "seeds": [
        "coffee grinder"
    ],
    "engines": [
        "google",
        "youtube",
        "amazon"
    ],
    "maxSuggestions": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/keyword-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "seeds": ["coffee grinder"],
    "engines": [
        "google",
        "youtube",
        "amazon",
    ],
    "maxSuggestions": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/keyword-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 '{
  "seeds": [
    "coffee grinder"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ],
  "maxSuggestions": 300
}' |
apify call dami_studio/keyword-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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