# Keyword Autocomplete Scraper - Google, YouTube, Amazon, Bing (`dami_studio/keyword-autocomplete-scraper`) Actor

The suggestions Google, YouTube, Amazon and Bing show as you type, for your seed keywords, by country and language. One row per suggestion with its rank and the exact text looked up. Add a to z, 0 to 9, question words or a trailing space for longer phrases. No API key.

- **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
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 google suggestion returneds

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

## Keyword Autocomplete Scraper

Start typing "coffee grinder" into Google in the US and it offers "coffee grinder for espresso", "coffee grinder walmart", "coffee grinder near me". Those guesses are real searches, ranked by the engine. This actor collects them for your seed keywords from Google, YouTube, Amazon and Bing, for the country and language you pick. You get one row per suggestion, with the rank the engine gave it and the exact text that was typed.

It asks each engine's own suggestion service, the one the search box calls while you type. No API key, no account.

### What it doesn't do

- **No search volume, cost per click or competition.** Suggestions tell you what people type, not how many of them do. If you need volumes, this is the wrong tool, however many suggestions it returns.
- **It's a snapshot.** Engines reshuffle their suggestions during the day. Run it again tomorrow and some will have changed.
- **Nothing personal.** The engines see a visitor with no history and no account, so you get what a signed-out searcher in that country is shown.
- **Google and Bing add a few local suggestions.** Both mix in suggestions for the area a search comes from, whatever country you set. In US runs that shows up as a handful of place names around Washington, D.C.: "guitar lessons alexandria va", "car insurance maryland". When we checked a German run against the same searches sent straight to each engine at the same moment, 252 of its 254 suggestions matched.
- **Amazon goes by the marketplace, not the language.** amazon.com gave the same list with its English and Spanish settings when we tried, and so did amazon.ca and amazon.ae with theirs.
- **Amazon sometimes corrects your spelling and answers that instead.** Asked for "does coffee grinder", it answered for "dose coffee grinder". Those answers are left out and not charged, and the status says how many there were.
- **Bing only answers for language and country pairs it has a market for.** English in Germany isn't one of them. When your pair isn't a market, Bing is asked in that country's own market and the status says so. For a country Bing has no market for at all, Bing is skipped.

### Input

**Seed keywords.** One per line, written the way you'd start a search. Up to 1,000 per run.

**Engines.** Google, YouTube, Amazon and Bing, in any combination. Google alone unless you choose otherwise.

**Country and Language.** Google and YouTube lean their suggestions toward the country and answer in the language. Asked "bank" in English, Google offered Bank of America for the US, Bank of Scotland for the UK and Bank of Baroda for India. Bing reads country and language together as one market.

**Amazon marketplace.** Match the country uses the Amazon of the country you picked (amazon.de for Germany), or amazon.com when that country has no Amazon of its own. Or pick one of the 23 marketplaces yourself.

**Amazon department.** Empty means all of Amazon. To stay inside one department, give Amazon's own short name for it, as it appears in its search links: `stripbooks` for books, `electronics`, `grocery`. A name Amazon doesn't know gets no suggestions, and the status tells you.

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

**Variations.** Each one adds lookups for every seed and engine:

- *Seed followed by a space* asks "coffee grinder " with the space typed. Engines often finish it differently.
- *a to z* asks "coffee grinder a" through "coffee grinder z". Most of the long phrases come from here.
- *0 to 9* is good for model numbers, sizes and years.
- *Question words* go in front: "how coffee grinder", "why coffee grinder". Change the list to suit you, or add words such as best or cheap.

With all four on, "coffee grinder" came back as 1,776 different suggestions from 204 lookups across the four engines, in about 15 seconds.

If an engine has no suggestions at all for a seed, its space, letter and number variations aren't asked. They only make the same text longer.

**Most suggestions per lookup.** Keep only the top of each list. Empty keeps all of it: up to 15 from Google, 14 from YouTube, 10 from Amazon and 25 from Bing.

**Maximum suggestions.** 5,000 unless you change it, and up to 50,000 per run, all engines together.

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

### Output

One row per suggestion, seed by seed. Within a seed, the seed's own lookup comes first, then the variations in the order above.

| Field | Example | Notes |
|---|---|---|
| `suggestion` | `coffee grinder for espresso` | as the engine wrote it |
| `rank` | `1` | its place in the engine's list for that lookup |
| `engine` | `google` | `google`, `youtube`, `amazon` or `bing` |
| `seed` | `coffee grinder` | the keyword you gave |
| `query` | `coffee grinder` | the exact text looked up, variation included |
| `expansionType` | `seed` | `seed`, `trailing space`, `letter`, `number` or `question` |
| `expansion` | `q` | the letter, digit or question word added; empty for the seed and the space |
| `country`, `language` | `US`, `en` | what the engine was asked for. For Bing, the market actually used. Amazon rows have the marketplace's country and no language |
| `marketplace` | `amazon.com` | Amazon rows only |
| `department` | `stripbooks` | Amazon rows asked inside a department |
| `searchType` | `web` | Google rows only |
| `suggestionType` | `query` | Google's own label. `navigation` means Google suggested a website address, such as https://www.amazon.com/ for "amazon" |
| `relevance` | `601` | Google's own score for the suggestion; Google rows only |
| `scrapedAt` | `2026-09-13T14:25:00.000Z` | when the engine answered |

A phrase comes back once per engine. If "coffee grinder electric" shows up under the seed, then again under "coffee grinder e", you get it once, from the first lookup that found it. Two engines suggesting the same phrase give you two rows, one each.

The run also leaves `RUN_REPORT` in its key-value store: how many lookups each engine was asked and answered, how many came back empty, repeats skipped, what each seed brought back, and why the run stopped.

### What you pay

Each suggestion in your dataset is one charge, at the price the Pricing tab shows for its engine. A lookup that comes back empty costs nothing, and neither does a phrase an engine already gave you in the same run. If you set a maximum charge for the run, it stops when that's reached, and every row you get has been paid for.

### Limits

- 1,000 seeds, 50,000 suggestions and 25,000 lookups per run.
- Each engine is asked a couple of lookups at a time, so a big run with every variation on takes several minutes.
- When an engine stops answering for a while, the actor waits and carries on. If it still doesn't answer, the status names the engine and says how many lookups were left out, and nothing is charged for them.

### Questions

**Why fewer rows than lookups times 15?** Repeats. Many variations bring back phrases an earlier lookup already found, and those aren't returned twice. Some lookups return short lists too: on amazon.com, "how coffee" got two suggestions.

**Can I track suggestions over time?** Schedule the actor with the same input and compare the datasets. `scrapedAt` and `rank` are there for that.

**Does it work in other alphabets?** Yes. Japanese, Korean, Russian and Hebrew seeds came back in their own scripts. The a to z variation adds Latin letters, which suits some languages better than others.

# 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. 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.

## `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"
  ],
  "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/9DU0MVHNbeghoD9oA/openapi.json