# Google Autocomplete Scraper – YouTube, Bing, Amazon (`ryumoon-data/keyword-autocomplete-expander`) Actor

Turn seed keywords into long-tail ideas from Google, YouTube, Bing and Amazon autocomplete. A-Z and question expansion, any country. Deduplicated with source and position. $0.50 per 1,000 suggestions.

- **URL**: https://apify.com/ryumoon-data/keyword-autocomplete-expander.md
- **Developed by:** [Ryu Moon](https://apify.com/ryumoon-data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 keyword suggestions

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

## Keyword Autocomplete: Google, YouTube, Bing & Amazon

**Turn one seed keyword into hundreds of long-tail keyword ideas from four autocomplete engines in a single run.** Google, YouTube, Bing and Amazon suggestions with optional A–Z, 0–9 and question expansion, any country and language, deduplicated, with the source and position of every suggestion. No API key or login needed. Export to JSON, CSV, Excel or Google Sheets.

### Use with AI agents (MCP, Claude, ChatGPT, Cursor)

**Purpose:** Expand seed keywords into long-tail keyword and question ideas from Google, YouTube, Bing and Amazon autocomplete, for any country and language.

**When to use it**

- SEO, content, YouTube or Amazon/Etsy listing keyword research: "give me long-tail keywords for X".
- Question ideas for FAQs and blog posts (`expandQuestions: true`).
- Comparing what people search for in different countries (`country`, `language`).

**When not to use it**

- It returns suggestions, not search volumes. For relative popularity over time, use [Google Trends Scraper](https://apify.com/ryumoon-data/google-trends-scraper-all-in-one) on the best suggestions.

**Example input**

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "sources": [
    "google",
    "amazon"
  ],
  "country": "GB",
  "language": "en",
  "expandQuestions": true,
  "maxSuggestionsPerKeyword": 200
}
```

**Output fields (one dataset item per row):** `seedKeyword`, `suggestion`, `sources` (engine and position for each), `bestPosition`, `query`, `expansion`, `wordCount`, `isQuestion`, `country`, `language`.

**Cost:** $0.005 per run + $0.0005 per unique suggestion (200 suggestions ≈ $0.11). Cap spend with `maxSuggestionsPerKeyword`.

**Connect it to your agent:** add this remote MCP server (Apify's official MCP server, loaded with just this tool):

```json
{"mcpServers": {"keyword-autocomplete-expander": {"url": "https://mcp.apify.com?tools=ryumoon-data/keyword-autocomplete-expander"}}}
```

Or call it from any agent with the Apify API: `POST https://api.apify.com/v2/acts/ryumoon-data~keyword-autocomplete-expander/run-sync-get-dataset-items` with the input above as the JSON body. Agents without an Apify account can pay per run with [agentic payments](https://docs.apify.com/agents/payments) (x402, MPP or Skyfire).

### What can this keyword tool do?

- 🔤 **Four engines at once**: Google web search, YouTube, Bing and Amazon autocomplete, side by side.
- 🧩 **A–Z and 0–9 expansion**: queries `seed a` … `seed z` (and `seed 0` … `seed 9`) to surface the long tail the plain seed doesn't show.
- ❓ **Question expansion**: `how seed`, `what seed`, `why seed`, `can seed` and more, in English, German, French, Spanish, Italian, Portuguese or Dutch. Good for FAQ sections, blog posts and "People also ask" style content.
- ➕ **Custom modifiers**: add your own prefixes (`best`, `cheap`) and suffixes (`for beginners`, `vs`, `near me`).
- 🌍 **Country and language**: e.g. `GB` + `en`, `DE` + `de`. Amazon uses the matching marketplace (amazon.co.uk, amazon.de …).
- 🧹 **Deduplicated**: one row per unique suggestion listing every engine that returned it and its position in each, so you can see which ideas show up everywhere.

### Use cases

- **SEO**: find long-tail keywords and question keywords for content briefs.
- **YouTube creators**: see what people type into YouTube search for a topic.
- **Amazon sellers and Etsy/eBay listings**: find buyer-intent product phrases for titles and backend keywords.
- **PPC**: build keyword and negative-keyword lists.
- **Market research**: compare what people search for in different countries and languages.

### How much does it cost?

This Actor uses pay-per-event pricing. You pay only for these events:

| Event | Price | When it is charged |
|---|---|---|
| Actor start | **$0.005** | Once per run (at the default 1 GB memory) |
| Keyword suggestion | **$0.0005** | Each unique suggestion saved to the dataset ($0.50 per 1,000) |

Examples (real counts will vary by keyword):

- 1 seed, 4 engines, no expansion (about 30–40 suggestions): about **$0.02**
- 1 seed, 4 engines, A–Z + questions (about 600 suggestions in our test): about **$0.31**
- 10 seeds, Google only, A–Z (about 2,000 suggestions): about **$1.00**

Duplicates are merged before charging, so a suggestion returned by all four engines is charged once. Use *Max suggestions per seed keyword* or a *maximum cost per run* in Apify Console to cap spend.

### Input

| Field | What it does | Default |
|---|---|---|
| `keywords` (required) | Seed keywords | `["coffee grinder"]` |
| `sources` | `google`, `youtube`, `bing`, `amazon` | all four |
| `country` / `language` | Two-letter codes | `US` / `en` |
| `expandAlphabet` | Add `seed a` … `seed z` | `false` |
| `expandDigits` | Add `seed 0` … `seed 9` | `false` |
| `expandQuestions` | Add question words before the seed | `false` |
| `customPrefixes` / `customSuffixes` | Your own modifiers | none |
| `mergeSources` | One row per suggestion (on) or per engine per suggestion (off) | `true` |
| `excludeSeedKeyword` | Drop the seed itself from results | `false` |
| `maxSuggestionsPerKeyword` | Cost cap per seed, 0 = no limit | `0` |
| `maxConcurrency`, `maxRequestRetries`, `proxyConfiguration` | Advanced | `4`, `3`, none |

```json
{ "keywords": ["coffee grinder", "espresso machine"], "country": "GB", "language": "en", "expandAlphabet": true, "expandQuestions": true }
```

### Output (one row per unique suggestion)

Real row from `sample-output.json`:

```json
{
  "seedKeyword": "coffee grinder",
  "suggestion": "coffee grinder walmart",
  "sources": ["google", "bing"],
  "positions": { "google": 4, "bing": 4 },
  "bestPosition": 4,
  "query": "coffee grinder",
  "expansion": "seed",
  "wordCount": 3,
  "isQuestion": false,
  "country": "US",
  "language": "en",
  "timesSuggested": 2,
  "scrapedAt": "2026-11-02T09:10:15.183Z"
}
```

- `query` is the text that was typed into the engine (e.g. `coffee grinder b`), `expansion` says how it was built (`seed`, `alphabet`, `question`, `custom-prefix`, `custom-suffix`).
- `positions` is the 1-based position in each engine's suggestion list; `timesSuggested` counts how often the suggestion appeared across all queries and engines.

### Limits (please read)

- **No search volumes or CPC.** Autocomplete shows what people type, not how often. Use the output as an idea list and check volumes in your SEO tool.
- **Suggestions are personalised by engines** to location and time; results from the Apify cloud can differ slightly from what you see in your own browser.
- **Up to about 10 suggestions per query per engine.** That is how many the engines return; use expansion to get more.
- **Amazon** only for the 13 listed marketplaces. Other countries skip Amazon with a warning.
- **Rate limits**: very large runs (hundreds of seeds with full expansion) can be slowed by the engines. The Actor retries with back-off; lower *Parallel requests* or add a proxy if you see failures in the `SUMMARY` record.

### FAQ

**Do I need an API key?** No. The Actor uses the same public autocomplete endpoints your browser uses when you type into a search box.

**Why do some suggestions appear for only one engine?** Each engine has its own data. Suggestions returned by several engines (`sources` with 2+ entries) are usually the strongest ideas.

**How do I get more results?** Turn on A–Z, 0–9 and question expansion, and add custom prefixes/suffixes.

**Is it legal?** It only reads public autocomplete suggestions, which contain no personal data. You are responsible for complying with each engine's terms for your use case. Defaults are deliberately gentle (4 parallel requests with retries and back-off).

### Integrations

Schedule it weekly per topic and send results to Google Sheets, Slack, a webhook, Zapier or Make with Apify integrations.

### Changelog

- 0.1 – first release: Google, YouTube, Bing and Amazon; A–Z, 0–9, question and custom expansion; cross-engine dedupe.

# Actor input Schema

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

One or more seed keywords or phrases, e.g. 'coffee grinder'. Each one is expanded separately.

## `sources` (type: `array`):

Which autocomplete engines to query: any of "google", "youtube", "bing", "amazon". Default: all four.

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

Two-letter country code, e.g. US, GB, DE, FR, IN. Amazon supports US, GB, DE, FR, IT, ES, NL, CA, MX, BR, IN, JP and AU; other countries skip Amazon.

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

Two-letter language code, e.g. en, de, fr, es.

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

Also query 'seed a', 'seed b' … 'seed z' (26 extra requests per source per keyword). Gives far more long-tail ideas.

## `expandDigits` (type: `boolean`):

Also query 'seed 0' … 'seed 9' (useful for years, sizes and models).

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

Also query question forms such as 'how seed', 'what seed', 'why seed', 'can seed'. Question words follow the Language setting (English, German, French, Spanish, Italian, Portuguese and Dutch; other languages use English). Good for FAQ and content ideas.

## `customPrefixes` (type: `array`):

Extra words to put before each seed, e.g. 'best', 'cheap', 'buy'.

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

Extra words to put after each seed, e.g. 'for beginners', 'vs', 'near me'.

## `mergeSources` (type: `boolean`):

On: one row per unique suggestion, listing every source and position that returned it. Off: one row per source per suggestion.

## `excludeSeedKeyword` (type: `boolean`):

Drop suggestions identical to the seed keyword.

## `maxSuggestionsPerKeyword` (type: `integer`):

0 = no limit. Use this to cap cost.

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

How many autocomplete requests run at once.

## `maxRequestRetries` (type: `integer`):

Retries with back-off when an endpoint rate-limits or fails.

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

Usually not needed. Use a proxy for very large runs if an engine starts rate-limiting.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "sources": [
    "google",
    "youtube",
    "bing",
    "amazon"
  ],
  "country": "US",
  "language": "en",
  "expandAlphabet": false,
  "expandDigits": false,
  "expandQuestions": false,
  "mergeSources": true,
  "excludeSeedKeyword": false,
  "maxSuggestionsPerKeyword": 0,
  "maxConcurrency": 4,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All suggestions stored in the run's default dataset.

# 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("ryumoon-data/keyword-autocomplete-expander").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("ryumoon-data/keyword-autocomplete-expander").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 ryumoon-data/keyword-autocomplete-expander --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ryumoon-data/keyword-autocomplete-expander"
        }
    }
}
```

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/Mz0G0gU3jsvKOYLWQ/builds/5F0efGs4sE6eZd4fM/openapi.json