# Keyword Suggest Scraper 🔤 (Google/YouTube/Amazon autocomplete) (`tagadanar/keyword-suggest-scraper`) Actor

Hundreds of real long-tail keyword ideas from Google, YouTube, Amazon and Bing autocomplete for your seed keywords: what people actually type. Alphabet and question-word expansion, any country and language, with position and question flag. No API key, no login.

- **URL**: https://apify.com/tagadanar/keyword-suggest-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** SEO tools, E-commerce, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 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.
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 Suggest Scraper: long-tail keyword ideas from Google, YouTube, Amazon and Bing autocomplete

Type a seed keyword, get hundreds of the exact phrases people really type into the search box. The actor reads the autocomplete dropdown of Google, YouTube, Amazon (14 marketplaces) and Bing, then expands every seed the way you would by hand: the seed followed by a to z and 0 to 9, plus question words (how, what, why, best...) and connectors (vs, for, with...). Every row says which seed, which source and exactly what was typed to surface it.

$0.50 per 1,000 suggestions, platform usage included. No API key, no login, no Google Cloud quota.

### Who uses it

- **SEO consultants and content marketers**: topic clusters, blog and FAQ ideas, question keywords people ask.
- **YouTubers and video SEO**: what viewers type on YouTube (a different list from Google's), for titles and tags.
- **Amazon sellers**: what shoppers type in Amazon's search box on your marketplace, for listings and backend keywords.
- **PPC teams**: long-tail and negative-keyword ideas to feed into a keyword planner.

### What you get

One row per distinct suggestion per seed per source (duplicates inside a source are removed):

| Field | Description |
| --- | --- |
| `source` | `google`, `youtube`, `amazon` or `bing` |
| `seedKeyword` | The seed this row came from |
| `suggestion` | The suggested phrase, as the source shows it |
| `queryUsed` | The exact text typed into the search box that surfaced it (e.g. `espresso machine a`, `how espresso machine`) |
| `position` | Place in the dropdown for that lookup, 1 = top |
| `depth` | 1 = from your seed, 2 = from expanding one of the top suggestions |
| `wordCount` | Number of words in the suggestion |
| `isQuestion` | True when it starts with a question word (how, what, why, wie, comment, cómo...) or ends with `?` |
| `country`, `language` | The country and language the suggestions are for |
| `searchUrl` | The public search page for that suggestion |
| `capturedAt` | When the row was collected |

#### Example row (real, from a run on 2026-10-16)

```json
{
  "source": "google",
  "seedKeyword": "espresso machine",
  "suggestion": "espresso machine at home",
  "queryUsed": "espresso machine a",
  "position": 7,
  "depth": 1,
  "wordCount": 4,
  "isQuestion": false,
  "country": "US",
  "language": "en",
  "searchUrl": "https://www.google.com/search?q=espresso%20machine%20at%20home&hl=en&gl=US",
  "capturedAt": "2026-10-15T23:14:23.200Z"
}
```

### How many suggestions will I get

One lookup returns about 10 suggestions, so the expansion is the product. Measured on 2026-10-16 for the seed "yoga mat" with the alphabet plus question words and depth 1: Google 496, YouTube 404, Amazon 380, Bing 467. A narrow seed gives fewer; the run status names every seed and source that ran out before your limit. Depth 2 also expands the first 5 suggestions of each seed and source, which finds many more (set a higher limit to use it). Amazon returns few suggestions for B2B or software topics (for "crm software" only 2).

### Input examples

Quick start (this is the default):

```json
{ "seedKeywords": ["espresso machine"], "sources": ["google", "youtube"], "expansion": "alphabet", "maxSuggestionsPerSeed": 100 }
```

Question keywords for content planning, German market:

```json
{ "seedKeywords": ["kaffeemaschine"], "sources": ["google"], "country": "DE", "language": "de", "expansion": "alphabet+questions", "maxSuggestionsPerSeed": 500 }
```

Amazon shopper phrases on amazon.co.uk, deep:

```json
{ "seedKeywords": ["yoga mat", "resistance bands"], "sources": ["amazon"], "country": "GB", "expansion": "alphabet", "depth": 2, "maxSuggestionsPerSeed": 1000 }
```

| Input | Meaning |
| --- | --- |
| `seedKeywords` | One seed per line, up to 100 |
| `sources` | `google`, `youtube`, `amazon`, `bing` (default Google + YouTube) |
| `country` | Country of the suggestions; for Amazon it picks the marketplace (US, GB, DE, FR, IT, ES, CA, JP, AU, MX, BR, NL, SE, PL) |
| `language` | Interface language (`en`, `de`, `fr`...). Question words are built in for English, German, French, Spanish, Italian and Portuguese; other languages use the English ones |
| `expansion` | `none` (about 10 ideas), `alphabet` (a-z and 0-9), `alphabet+questions` |
| `depth` | 1 or 2 (2 also expands the first 5 suggestions per seed and source) |
| `maxSuggestionsPerSeed` | Limit per seed and per source, default 300, up to 2,000 |

### Pricing

Pay per suggestion delivered, platform usage included:

| Plan | Per 1,000 suggestions |
| --- | --- |
| Free | $0.50 |
| Bronze | $0.45 |
| Silver | $0.40 |
| Gold | $0.35 |

Plus $0.001 per run to start. Seeds a source has no suggestions for are not charged. Set a maximum charge per run and the actor stops there.

### FAQ

**Is this search volume data?** No. Autocomplete shows what people type, in the order the search engine ranks it, not how many searches there are. Use it to find the ideas, then check volume in your keyword tool.

**Why do Google and YouTube give different lists?** They are different search boxes. YouTube leans to tutorials, reviews and "vs" videos; Google leans to products, questions and local intent.

**Does it use my country and language?** Yes: `country` and `language` are sent with every lookup. Autocomplete can still vary a little between runs because the sources personalise and refresh their suggestions.

**Why is Amazon missing for my country?** Amazon has a suggestion service for the 14 marketplaces listed above. For other countries (India, for example) Amazon is skipped and the run status says so, instead of returning an empty list.

**A seed returned nothing.** The run status says whether the source answered with an empty list (nothing to suggest, usually a very unusual phrase), refused, or was cut by the run time limit. It never reports a refusal as an empty result.

**Are results the same as typing in the browser?** They come from the same suggestion services the search boxes call. Positions are the dropdown order for that lookup.

### Related actors

- [YouTube Search Scraper](https://apify.com/tagadanar/youtube-search-scraper): see which videos rank for the keywords you found.
- [YouTube Channel Scraper](https://apify.com/tagadanar/youtube-channel-scraper): study the channels behind those videos.
- [Amazon Product Scraper](https://apify.com/tagadanar/amazon-product-scraper): pull the products and prices behind an Amazon keyword.
- [Google Trends Scraper](https://apify.com/tagadanar/google-trends-scraper): compare the interest over time of your best keywords.

# Changelog

This Actor's version history is a separate document: https://apify.com/tagadanar/keyword-suggest-scraper/changelog.md

# Actor input Schema

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

One seed keyword or phrase per line, e.g. a product, a topic or a competitor. Each seed is expanded separately and every row says which seed it came from. Duplicates are removed.

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

Which search boxes to read. Google and YouTube suggestions differ a lot (YouTube leans to tutorials and reviews), Amazon shows what shoppers type before buying, Bing is the long-tail tail of the Microsoft search box.

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

Country the suggestions are for (Google/YouTube 'gl'; for Amazon it picks the marketplace: US, GB, DE, FR, IT, ES, CA, JP, AU, MX, BR, NL, SE, PL have one; other countries skip Amazon and the run says so).

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

Interface language of the suggestions (Google/YouTube/Bing 'hl'). Also picks the question words used by 'Add question words' (English, German, French, Spanish, Italian, Portuguese; other languages use the English ones). Amazon answers in its marketplace's own language.

## `expansion` (type: `string`):

'Seed only' returns about 10 suggestions. 'Alphabet' adds the seed followed by a-z and 0-9 (what a person sees typing one more letter), which is where the long tail is. 'Alphabet + question words' also tries how/what/why/best… before the seed and vs/for/with… after it.

## `depth` (type: `integer`):

1 = expand your seed only. 2 = also expand the first 5 suggestions found for each seed and source the same way (a much longer tail and many more lookups; raise the cap to use it).

## `maxSuggestionsPerSeed` (type: `integer`):

Stop each seed on each source after this many different suggestions. You only pay for suggestions delivered. A common seed with the alphabet plus question words gives roughly 350-500 per source (measured on 'yoga mat': Google 496, YouTube 404, Amazon 380, Bing 467); niche seeds give fewer, and depth 2 gives more.

## Actor input object example

```json
{
  "seedKeywords": [
    "espresso machine"
  ],
  "sources": [
    "google",
    "youtube"
  ],
  "country": "US",
  "language": "en",
  "expansion": "alphabet",
  "depth": 1,
  "maxSuggestionsPerSeed": 100
}
```

# Actor output Schema

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

One item per suggestion per source per seed keyword in the 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 = {
    "seedKeywords": [
        "espresso machine"
    ],
    "sources": [
        "google",
        "youtube"
    ],
    "expansion": "alphabet",
    "depth": 1,
    "maxSuggestionsPerSeed": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/keyword-suggest-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 = {
    "seedKeywords": ["espresso machine"],
    "sources": [
        "google",
        "youtube",
    ],
    "expansion": "alphabet",
    "depth": 1,
    "maxSuggestionsPerSeed": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/keyword-suggest-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 '{
  "seedKeywords": [
    "espresso machine"
  ],
  "sources": [
    "google",
    "youtube"
  ],
  "expansion": "alphabet",
  "depth": 1,
  "maxSuggestionsPerSeed": 100
}' |
apify call tagadanar/keyword-suggest-scraper --silent --output-dataset

```

## MCP server setup

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