# Google Autocomplete & Keyword Suggestions: 10 Search Engines (`data-done-right/keyword-suggestions-tool`) Actor

Google autocomplete scraper and keyword suggestions tool: Google search suggestions plus YouTube, Amazon keywords, Bing, DuckDuckGo, eBay, Yahoo and App Store autocomplete in one run. Alphabet and question expansion, recursive depth, cross-engine agreement score. No search volume data.

- **URL**: https://apify.com/data-done-right/keyword-suggestions-tool.md
- **Developed by:** [Data Done Right](https://apify.com/data-done-right) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.44 / 1,000 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

## Google Autocomplete & Keyword Suggestions: 10 Search Engines

This **Google autocomplete scraper** and keyword suggestions tool collects autocomplete keyword ideas for SEO, content and e-commerce from **ten search boxes in one run**: Google, YouTube, Google Shopping, Bing, DuckDuckGo, Amazon, eBay, Apple App Store, Yahoo and Yandex. These are the same public suggestion endpoints the search boxes call, so there are no logins and no API keys.

Give it seed keywords, pick engines and countries, and switch on the expansions you want. You get **one row per suggestion**, plus a **cross-engine agreement score** that shows which ideas several engines agree on.

### What makes it different

- **Many engines, one dataset.** Compare what people type into Google, YouTube, Amazon, eBay and the App Store side by side.
- **Expansion modes.** Alphabet soup (`seed a` to `seed z`, `seed 0` to `seed 9`), question words (`how`, `what`, `why`, `when`, `where`, `can`, `is`, `does`, `best` ...), prepositions and comparisons (`for`, `with`, `without`, `near me`, `vs`, `or` ...), your own `{seed}` templates, and **recursive depth** (suggestions of suggestions, capped).
- **Agreement score.** Every row carries `foundOnEngines` (how many of the engines you queried returned this suggestion) and `independentSources`, which counts Bing, DuckDuckGo and Yahoo as one source because their suggestions overlap heavily.
- **Per-seed summary** (unique suggestions, top words, which engines agree and overlap) in the `SUMMARY` record.
- **Country and language** per run (`US-en`, `DE-de`, `GB-en`, `FR-fr` ...). Question and preposition words are built in for en, de, fr, es, it, pt and nl.
- **Reliable.** Retries with backoff, a fresh proxy session when an engine answers with a block page, and an engine that fails every request is stopped and reported rather than hammered. Failures are listed in the `NOTES` record, never silent.
- **Cost caps.** `maxSuggestions` and `maxRequests` stop the run, and the planned request count is logged at the start.

### Input example

```json
{
  "seedKeywords": ["coffee maker", "standing desk"],
  "engines": ["google", "youtube", "bing", "duckduckgo", "amazon"],
  "locales": ["US-en"],
  "alphabetSoup": true,
  "questionModifiers": true,
  "prepositionModifiers": false,
  "customTemplates": ["best {seed} for"],
  "recursiveDepth": 1,
  "maxSuggestions": 2000
}
```

### Output example (one row per engine and suggestion)

```json
{
  "engine": "google",
  "seed": "coffee maker",
  "query": "coffee maker",
  "suggestion": "coffee maker with grinder",
  "position": 2,
  "country": "US",
  "language": "en",
  "modifierType": "base",
  "depth": 0,
  "foundOnEngines": 8,
  "enginesQueried": 10,
  "independentSources": 6,
  "engines": ["google", "youtube", "google-shopping", "bing", "duckduckgo", "amazon", "ebay", "yahoo"],
  "timesSeen": 1
}
```

- `query` is what was typed into the search box, `position` is the rank in that engine's answer.
- `modifierType` is `base`, `alphabet`, `number`, `question`, `preposition`, `custom` or `recursive`; `depth` is 0 for the seed and its modifiers, 1+ for recursive levels.
- Duplicates are removed **within an engine** (case and spacing ignored). The row kept is the earliest and highest-ranked one; `timesSeen` says how many queries returned it. A suggestion that only repeats the query you typed is dropped.
- Rows are ordered so the suggestions found on the most engines come first.

`SUMMARY` (key-value store) has one object per seed and country: `uniqueSuggestions`, `suggestionsPerEngine`, `foundOnNEngines`, `topAgreed`, `topWords`, `engineOverlap`. `NOTES` lists skipped engines, failures and any limit that cut the run short.

### Use cases

- SEO and content: long-tail ideas, questions people ask, comparison keywords (`x vs y`).
- E-commerce: what shoppers type on Amazon and eBay, per country.
- YouTube and app research: video topic ideas and App Store search hints.
- Find the ideas that show up on several engines and are therefore safer bets.

### Engines and limits (please read)

- **Autocomplete only.** There is no search volume, CPC or competition data, because the engines do not publish it.
- Suggestions are personalised a little by location. Google and YouTube accept any country and language. **Amazon** (18 marketplaces), **eBay** (13 sites), **Yahoo** (12 regions) and the **App Store** (18 storefronts) are chosen by country only, and an unsupported country is skipped and listed in `NOTES`. Amazon India is not available from the suggestion API.
- DuckDuckGo sometimes adds local-business style suggestions based on the server's location.
- Question and preposition words exist only for en, de, fr, es, it, pt and nl. For other languages use **Custom templates** (they work in any language) and, for non-Latin scripts, **Custom characters** for the alphabet. Default letters are a-z and 0-9 (Cyrillic for ru and uk).
- Each engine returns about 4 to 14 suggestions per query, so a big expansion means many requests: with alphabet soup, questions and prepositions, one seed on one engine is about 65 requests. `recursiveDepth` multiplies that. Use `maxRequests` and `maxSuggestions`.
- Google, YouTube and Google Shopping use the residential Apify proxy by default because Google blocks datacenter and home IPs quickly. Other engines are queried directly; there is an option to use the datacenter proxy if one starts blocking.
- Autocomplete endpoints are unofficial. If an engine changes or blocks them the run reports it in `NOTES` instead of returning a silent empty result.

### Amazon autocomplete keywords

Add `amazon` to **Engines** and enter a product idea as the seed. You get what shoppers type into the Amazon search box, which is a quick way to find product keywords and long-tail phrases.

### YouTube keyword ideas

Add `youtube` to **Engines**. The suggestions come from the YouTube search box, so they show what people search for on YouTube: video topics, titles and tags.

### Google autocomplete questions

Turn on **Question modifiers**. The Actor adds "how", "what", "why", "can" and similar words to each seed, so you get the questions people ask Google about your keyword.

### Google autocomplete API

Call it from the Apify API, Python, JavaScript, Make, Zapier or n8n. Example with the Apify Python client:

```python
from apify_client import ApifyClient

run = ApifyClient("<APIFY_TOKEN>").actor("data-done-right/keyword-suggestions-tool").call(run_input={
    "seedKeywords": ["standing desk"], "engines": ["google", "amazon"], "questionModifiers": True})
```

Then read the suggestions from the run's default dataset.

### Use it in Claude, ChatGPT and Cursor

Connect Apify's MCP server (mcp.apify.com) and your AI assistant can collect keyword ideas itself. For example: "give me question keywords for 'standing desk' from Google, and the ideas Amazon and Bing also suggest." The only required input is `seedKeywords`; `engines` picks the search boxes.

### How much does it cost

Pay per event: **$0.00055 per suggestion row delivered** (about $0.55 per 1,000 rows), with **no per-run start fee**. Paid Apify plans get 10% (Silver) to 20% (Gold and up) off. Failed requests and skipped engines cost nothing, and the caps above bound the bill. Platform usage (proxy traffic is tiny: about 5 KB per request) is small for these runs.

### Tips

- Start with 1 seed and 2 or 3 engines to see volume, then scale up.
- Compare `foundOnEngines >= 3` rows across Google, Amazon and YouTube to find ideas with broad demand.
- Schedule weekly runs with Apify Schedules to watch how suggestions change.
- Pair with our Google Trends Actor to check interest over time for the best ideas.

### FAQ

#### How do I get Google keyword suggestions in bulk?

Enter your seed keywords, choose Google (and any other engines), and switch on alphabet soup and question modifiers. You get one row per suggestion, with the modifier that produced it.

#### Where do the suggestions come from?

From the public autocomplete endpoints behind each search box: Google, YouTube, Google Shopping, Bing, DuckDuckGo, Amazon, eBay, the Apple App Store, Yahoo and Yandex. No login or API key is needed.

#### Does it show search volume or keyword difficulty?

No. Autocomplete only. Engines do not publish volume, CPC or competition data, so this tool does not invent it. The `foundOnEngines` agreement score shows which ideas several engines agree on.

#### Can I find question keywords, like "how" and "can" searches?

Yes. Question modifiers (`how`, `what`, `why`, `when`, `where`, `can`, `is`, `does`, `best` and more) are built in for English, German, French, Spanish, Italian, Portuguese and Dutch. Use custom templates for other languages.

#### Can I get keyword suggestions for YouTube or Amazon?

Yes. Pick YouTube, Amazon, eBay or the App Store, and set the country. Amazon, eBay, Yahoo and the App Store are chosen by country only.

#### How much do keyword suggestions cost?

It is pay per event: $0.00055 per suggestion delivered with no start fee, and failed requests are free. `maxSuggestions` and `maxRequests` cap the bill, so start with one seed and a few engines.

### Related tools

- **[Google Trends Scraper](https://apify.com/data-done-right/google-trends-scraper)** checks interest over time and rising queries for your best ideas.
- **AI Visibility Tracker** shows whether ChatGPT, Claude and Gemini mention your brand for those topics.

# Actor input Schema

## `seedKeywords` (type: `array`):

One keyword or phrase per line. Each one is sent to every engine you pick. Example: pdf to text, project management software.

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

Which search boxes to ask. Google, YouTube and Google Shopping use the residential proxy below by default.

## `locales` (type: `array`):

One per line as COUNTRY-language, e.g. US-en, DE-de, GB-en, FR-fr. A bare country (DE) uses its main language. Every seed runs once per locale.

## `alphabetSoup` (type: `boolean`):

Also query each seed with a letter or digit added (coffee maker a, coffee maker b ...). Adds 36 queries per seed and engine.

## `alphabetPosition` (type: `string`):

Where the letter or digit goes relative to the seed.

## `alphabetCharacters` (type: `string`):

Optional. Replace the default a-z, 0-9 with your own characters, e.g. for Cyrillic, Greek or Japanese kana. Leave empty for the default.

## `questionModifiers` (type: `boolean`):

Add question words in front of the seed (how, what, why, when, where, who, can, is, does, best ...). Built in for en, de, fr, es, it, pt, nl.

## `prepositionModifiers` (type: `boolean`):

Add words after the seed (for, with, without, near me, vs, or, and, like ...). Built in for en, de, fr, es, it, pt, nl.

## `customTemplates` (type: `array`):

Your own patterns, one per line, with {seed} where the keyword goes. Example: best {seed} for, {seed} under $, why is {seed}. Works in any language.

## `recursiveDepth` (type: `integer`):

0 = off. 1 = also query the top new suggestions (suggestions of suggestions). Max 3. Each level multiplies the number of requests.

## `recursiveBranching` (type: `integer`):

For recursion: how many new suggestions per engine, seed and level are queried again.

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

Hard cap on output rows (and on cost) for the whole run. 0 = no cap. When it cuts, rows found on the most engines are kept first.

## `maxRequests` (type: `integer`):

Hard cap on requests sent to the engines for the whole run.

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

Polite default is 3. Google-family engines are limited to 3 regardless.

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

Amazon search alias: aps = all departments, or e.g. electronics, fashion, garden, toys-and-games, books.

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

Google blocks datacenter and home IPs quickly. Residential Apify proxy is the default for Google, YouTube and Google Shopping.

## `useProxyForOtherEngines` (type: `boolean`):

Off by default: Bing, DuckDuckGo, Amazon, eBay, Yahoo, Yandex and the App Store are queried directly. Turn on if an engine starts blocking.

## Actor input object example

```json
{
  "seedKeywords": [
    "coffee maker"
  ],
  "engines": [
    "google",
    "bing",
    "amazon"
  ],
  "locales": [
    "US-en"
  ],
  "alphabetSoup": true,
  "alphabetPosition": "after",
  "questionModifiers": false,
  "prepositionModifiers": false,
  "recursiveDepth": 0,
  "recursiveBranching": 8,
  "maxSuggestions": 100,
  "maxRequests": 5000,
  "maxConcurrency": 3,
  "amazonDepartment": "aps",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "useProxyForOtherEngines": false
}
```

# Actor output Schema

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

All result items of this run (the default dataset), as JSON, CSV, Excel and more.

## `records` (type: `string`):

Key-value store records: the run summary, notes on any problems, and any files.

# 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 = {
    "seedKeywords": [
        "coffee maker"
    ],
    "engines": [
        "google",
        "bing",
        "amazon"
    ],
    "locales": [
        "US-en"
    ],
    "maxSuggestions": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-done-right/keyword-suggestions-tool").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 = {
    "seedKeywords": ["coffee maker"],
    "engines": [
        "google",
        "bing",
        "amazon",
    ],
    "locales": ["US-en"],
    "maxSuggestions": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("data-done-right/keyword-suggestions-tool").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 '{
  "seedKeywords": [
    "coffee maker"
  ],
  "engines": [
    "google",
    "bing",
    "amazon"
  ],
  "locales": [
    "US-en"
  ],
  "maxSuggestions": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call data-done-right/keyword-suggestions-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-done-right/keyword-suggestions-tool"
        }
    }
}
```

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/MeDzuUHaLYMe7cMPw/builds/U2ttM8f3EgCgl1Zft/openapi.json