# Keyword Suggestions: Google, YouTube, Bing, Amazon Autocomplete (`reliable-feeds/autocomplete-keyword-ideas`) Actor

Keyword suggestions from Google, YouTube, Bing and Amazon autocomplete in one run, plus the questions people ask, in any country and language. Billed per lookup, not per suggestion: each lookup returns up to 10–25 ideas for $0.0005. Failed lookups are free.

- **URL**: https://apify.com/reliable-feeds/autocomplete-keyword-ideas.md
- **Developed by:** [Reliable Feeds](https://apify.com/reliable-feeds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 successful lookups

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

### What does Keyword Suggestions do?

It turns a few seed keywords into hundreds of real search phrases from the autocomplete boxes of **Google, YouTube, Bing and Amazon**, all in one run. It's for SEO writers, YouTube creators, Amazon sellers and PPC managers who want the words people actually type, plus the questions they ask.

**You pay per lookup, not per suggestion.** One lookup (one typed query) returns up to 10–25 suggestions for $0.0005. Example from a test on 17 Oct 2026: the seed "standing desk" on Google with alphabet + questions made 40 lookups and returned 527 unique ideas, 126 of them questions, for $0.025 in total. Results vary by keyword and source.

### Features

- 🌐 **4 sources in one run:** Google, YouTube, Bing (up to 25 per lookup) and Amazon (US, CA, MX, GB, DE, FR, IT, ES)
- ❓ **Question finder:** "how / what / why / can / is …" questions, each row flagged `isQuestion`
- 🔤 **Long-tail expansion:** alphabet (a–z), numbers, prepositions (for, with, vs) and depth 2, which looks up the top suggestions again
- 🌍 **Any country and language:** set country `gb` and language `en`, or `de` and `de`
- 🧹 **Clean output:** de-duplicated and ranked, with word count
- ✅ **Fair billing:** failed or blocked lookups are retried and never charged
- 📏 **Limits:** up to 1,000 seed keywords per run; set **Maximum results** or a maximum cost to stay within budget

### Who uses it

- **SEO and content:** blog topics, FAQ questions and long-tail pages.
- **YouTube creators:** what people type before they search for a video, for titles and tags.
- **Amazon sellers:** shopper words for listing titles and backend search terms.
- **PPC:** keyword and negative-keyword lists, fast.
- **AI agents and automations:** cheap, predictable keyword ideas through the API or the Apify MCP server.

> Need search volume, CPC and difficulty for these ideas? Run them through [Keyword Search Volume](https://apify.com/reliable-feeds/keyword-search-volume).

### One tool, many jobs

Use it as a:

- **Google autocomplete scraper**: Google search suggestions for any country and language.
- **YouTube keyword tool**: YouTube search suggestions for video titles, tags and topics.
- **Amazon keyword tool**: Amazon search suggestions for listing titles and backend search terms.
- **Bing suggestions scraper**: up to 25 suggestions per lookup.
- **Question finder**: the "how / what / why / can / is …" questions people search, ready for FAQs and blog posts. Filter on `isQuestion = true`.
- **Long-tail keyword generator**: alphabet, number, preposition and depth-2 expansion.
- **AnswerThePublic-style research** without a subscription.

### How to use it

1. Type one or more seed keywords, one per line.
2. Pick your sources (Google is on by default).
3. Pick expansions. Alphabet and Questions are a good start.
4. Set your country and language.
5. Click **Start**, then download the results as CSV, Excel or JSON, or connect them to Google Sheets, Make, Zapier or your own code through the API.

#### Example input

```json
{
  "keywords": ["standing desk"],
  "sources": ["google", "youtube", "amazon"],
  "expansions": ["alphabet", "questions"],
  "country": "us",
  "language": "en",
  "depth": 1,
  "maxResults": 2000
}
```

#### Use it from AI agents (MCP)

This Actor works through the [Apify MCP server](https://apify.com/apify/actors-mcp-server), so Claude, ChatGPT, Cursor and other agents can call it directly. Ask for something like *"Find the questions people search about standing desks on Google and YouTube"*. Input is a plain list of keywords, and the output is flat JSON with stable field names.

#### Integrations

Run it on a schedule, then send the results to Google Sheets, Slack, Make, Zapier or n8n, or call it from your own code through the Apify API (Python, JavaScript or HTTP).

### Output

One row per unique suggestion. Example row:

```json
{
  "keyword": "standing desk",
  "suggestion": "why is standing desk better than sitting",
  "source": "google",
  "query": "why standing desk",
  "modifierType": "questions",
  "modifier": "why",
  "position": 1,
  "depth": 1,
  "country": "us",
  "language": "en",
  "wordCount": 7,
  "isQuestion": true
}
```

| Field | Meaning |
|---|---|
| `keyword` | Your seed keyword |
| `suggestion` | The autocomplete suggestion |
| `source` | `google`, `youtube`, `bing` or `amazon` |
| `query` | The exact text typed to get it |
| `modifierType` | `seed`, `alphabet`, `numbers`, `questions`, `prepositions` or `second_level` |
| `position` | Rank in the autocomplete list (1 = top) |
| `isQuestion` | True when the suggestion is a question |

A run summary (requests, failures, results per source) is saved to the key-value store as `RUN_SUMMARY`.

### How much does it cost?

Pay per event, no subscription:

- **$0.005** per run (start)
- **$0.0005** per successful lookup

You are billed per **lookup** (one typed query), not per suggestion. Each lookup returns up to 10–25 suggestions. Failed or blocked lookups are retried and never charged. Duplicates are removed for free.

| What you run | Lookups | Typical ideas returned | Cost |
|---|---|---|---|
| 1 keyword, Google, no expansion | 1 | 10–15 | $0.0055 |
| 1 keyword, Google, alphabet + questions | 40 | about 500 | $0.025 |
| 10 keywords, Google + YouTube, alphabet + questions | 800 | about 5,000–9,000 | about $0.41 |

Lookups per keyword per source: 1 for the keyword itself, +26 for alphabet, +13 for questions, +15 for prepositions, +10 for numbers. Depth 2 adds up to "Suggestions to dig into" more.

Set **Maximum results** or a maximum cost per run to stay within budget. The run stops cleanly when either is reached.

### Sources and countries

| Source | Results per lookup | Countries |
|---|---|---|
| Google | up to 15 | Any (`country` + `language`) |
| YouTube | up to 10 | Any |
| Bing | up to 25 | Any market Bing supports, e.g. `en-US`, `en-GB`, `de-DE` |
| Amazon | up to 10 | US, CA, MX, GB, DE, FR, IT, ES |

### FAQ

**Does it give search volume?** No. Autocomplete shows what people search, ranked, but not how many. For volume, CPC and difficulty, run the results through [Keyword Search Volume](https://apify.com/reliable-feeds/keyword-search-volume).

**Do I need a proxy?** Usually not. If a run shows many failed requests, switch on the proxy in the Advanced section and lower Parallel requests.

**Is any personal data collected?** No. Autocomplete suggestions are aggregated public search phrases. You are responsible for how you use the results and for following the terms of the services involved.

**Something wrong or missing?** Open an issue on the Issues tab and it will be looked at.

# Actor input Schema

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

One topic per line, e.g. 'fire alarm' or 'standing desk'. Up to 1,000 per run.

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

Google web search, YouTube, Bing and Amazon. Amazon supports US, CA, MX, GB, DE, FR, IT and ES.

## `expansions` (type: `array`):

Alphabet adds 'keyword a' to 'keyword z' (26 extra lookups). Questions adds 'how/what/why... keyword' (13). Prepositions adds 'keyword for/with/vs...' (15). Numbers adds 'keyword 0-9' (10). Leave empty for the plain keyword only.

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

Two-letter country code, e.g. us, gb, de, fr, in, au.

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

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

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

1 = suggestions for your keywords. 2 = also look up the top suggestions themselves, for long-tail ideas.

## `maxSecondLevelSeeds` (type: `integer`):

Only used when depth is 2.

## `maxResults` (type: `integer`):

The run stops after this many unique suggestions. You are only charged per result delivered.

## `concurrency` (type: `integer`):

Keep this low (1-4) unless you use a proxy.

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

Not needed for most runs. Turn on if you see many failed requests.

## Actor input object example

```json
{
  "keywords": [
    "standing desk",
    "fire alarm"
  ],
  "sources": [
    "google"
  ],
  "expansions": [
    "alphabet",
    "questions"
  ],
  "country": "us",
  "language": "en",
  "depth": 1,
  "maxSecondLevelSeeds": 20,
  "maxResults": 5000,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `keywordIdeas` (type: `string`):

Unique autocomplete suggestions with source, rank, modifier, question flag and word count.

## `runSummary` (type: `string`):

Lookups made, failures and result counts per source.

# 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": [
        "standing desk",
        "fire alarm"
    ],
    "sources": [
        "google"
    ],
    "expansions": [
        "alphabet",
        "questions"
    ],
    "country": "us",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable-feeds/autocomplete-keyword-ideas").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": [
        "standing desk",
        "fire alarm",
    ],
    "sources": ["google"],
    "expansions": [
        "alphabet",
        "questions",
    ],
    "country": "us",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("reliable-feeds/autocomplete-keyword-ideas").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": [
    "standing desk",
    "fire alarm"
  ],
  "sources": [
    "google"
  ],
  "expansions": [
    "alphabet",
    "questions"
  ],
  "country": "us",
  "language": "en"
}' |
apify call reliable-feeds/autocomplete-keyword-ideas --silent --output-dataset

```

## MCP server setup

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

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/Mkk3CUd5Q7RBXGQgu/builds/4autkIwxrTc7bCadw/openapi.json