# Keyword Suggestions: Google, YouTube, Bing, Amazon Autocomplete (`transparent_meteorite/keyword-suggestions-autocomplete`) Actor

Keyword suggestions from Google, YouTube, Bing, Amazon and DuckDuckGo autocomplete. A-Z, question and preposition expansion, merged and deduped, per country and language. No proxy, no key.

- **URL**: https://apify.com/transparent_meteorite/keyword-suggestions-autocomplete.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 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.
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 Suggestions: Google, YouTube, Bing, Amazon Autocomplete

Keyword suggestions for SEO, content and product research: this Actor returns the autocomplete suggestions that Google, YouTube, Bing, Amazon and DuckDuckGo show as people type, expanded with A-Z, 0-9, question words and prepositions, merged across engines and deduped. One tiny JSON call per query, no proxy, no browser, no API key.

Type a seed such as "coffee maker" and the Actor asks each engine what people search next: "coffee maker with grinder", "coffee maker walmart", "how to clean a coffee maker". It repeats that for every expansion you pick, so one seed becomes hundreds of real long-tail keywords with the engine, the rank each engine gave it, the country and the language. Use it as a Google autocomplete scraper, a YouTube keyword tool, an Amazon search suggestion finder or a Bing keyword suggestion tool, all in one run.

### Run in 30 seconds

1. Open the **Input** tab. The prefill researches "coffee maker" on Google, YouTube and Bing with plain and A-Z expansion, capped at 300 rows.
2. Click **Start**. It finishes in a few seconds.
3. Open the **Suggestions** table in the Output tab, or export JSON, CSV or Excel.
4. Replace the seed with your own topic, add engines and expansions, raise **Max suggestions** and run again.

### What does this Actor do?

Autocomplete is the cheapest, freshest keyword signal there is: it shows what real people type right now, per country and per platform. This Actor calls each engine's public suggestion endpoint, which returns a small JSON list, so it needs no proxy and no browser. A run with five engines and 40 expansions is about 200 tiny calls and finishes in well under a minute.

| Engine | What it tells you | Country and language |
|---|---|---|
| Google | General web search demand, with Google's relevance score | Region and interface language |
| YouTube | Video topics and how-to demand | Region and interface language |
| Bing | Bing and Copilot search demand | Market, for example en-US or de-DE |
| Amazon | Product search terms shoppers use | Marketplace of the country (US, UK, DE, FR, IT, ES, CA, JP, IN, AU, MX, BR and more) |
| DuckDuckGo | Privacy search demand | Region and language |
| Google Shopping | Product phrases in Google Shopping | Region and language |
| Google Images | Visual search phrases | Region and language |

### Expansion modes

| Mode | Queries sent per seed | Example |
|---|---|---|
| Plain | 1 | `coffee maker` |
| A-Z | 26 | `coffee maker a`, `coffee maker b` ... |
| 0-9 | 10 | `coffee maker 1` ... |
| Question words | 14 | `how coffee maker`, `what coffee maker`, `why coffee maker`, `can coffee maker` ... |
| Prepositions | 13 | `coffee maker for`, `coffee maker with`, `coffee maker vs`, `coffee maker near` ... |

You can combine modes. Each query is sent to each engine you picked, so the number of calls is seeds x queries x engines.

### Output fields

Every row has the same core fields, so it drops straight into a sheet or a database.

| Field | Meaning |
|---|---|
| `seed` | The keyword you gave |
| `query` | The exact text sent to the engine, for example `coffee maker b` |
| `expansion` | Which mode produced the query: plain, alphabet, digits, questions, prepositions |
| `suggestion` | The suggested keyword |
| `searchUrl` | Link to that suggestion's search results on the engine, ready to open |
| `engine` | Engine that returned it (separate rows mode) |
| `rank` | Position in that engine's list, 1 is first |
| `relevance` | Google's own relevance score when Google or YouTube provides one |
| `suggestionType` | The engine's label for the suggestion, when it gives one |
| `engines`, `engineCount`, `bestRank` | In merged mode: every engine that returned it, how many, and the best rank |
| `timesSeen` | How many queries returned the same suggestion |
| `country`, `language` | The region and language used |
| `wordCount`, `charCount` | Length of the suggestion |
| `isQuestion` | True for question style keywords such as "how to descale a coffee maker" |

Nullable fields (`relevance`, `suggestionType`) are `null` when the engine does not send them.

### Merged mode and duplicates

- **Remove duplicates** is on by default: each suggestion is returned once per engine, with its best rank.
- **Merge engines** turns the dataset into one row per unique suggestion with an `engines` list. Keywords that two or more engines agree on are strong demand signals, and `engineCount` lets you sort by that agreement.
- Turn duplicates off if you want to see every hit from every query.

### Input

| Field | What it does |
|---|---|
| `seeds` | One or more words or phrases, one per line. |
| `engines` | google, youtube, bing, amazon, duckduckgo, googleShopping, googleImages. Default google, youtube, bing. |
| `expansions` | plain, alphabet, digits, questions, prepositions. Default plain, alphabet, questions. |
| `country` | Two-letter code such as us, gb, de, fr, jp. |
| `language` | Language code such as en, de, fr, es, ja. |
| `mergeEngines` | One row per unique suggestion with an engines list. |
| `removeDuplicates` | Return each suggestion once. Default on. |
| `maxResults` | Hard cap on rows for the whole run. Default 5000. |
| `concurrency` | Parallel calls, 1 to 15. Default 6. |

### Example input

```json
{
  "seeds": ["coffee maker", "espresso machine"],
  "engines": ["google", "youtube", "bing", "amazon"],
  "expansions": ["plain", "alphabet", "questions", "prepositions"],
  "country": "us",
  "language": "en",
  "mergeEngines": true,
  "maxResults": 3000
}
```

### Output sample

```json
{
  "seed": "coffee maker",
  "query": "coffee maker",
  "expansion": "plain",
  "suggestion": "coffee maker with grinder",
  "searchUrl": "https://www.google.com/search?q=coffee%20maker%20with%20grinder&hl=en&gl=us",
  "country": "us",
  "language": "en",
  "wordCount": 4,
  "charCount": 25,
  "isQuestion": false,
  "timesSeen": 12,
  "engines": ["google", "youtube", "bing", "amazon", "duckduckgo"],
  "bestRank": 1,
  "engineCount": 5
}
```

The values above are an illustration of merged mode. Your own run returns the real, current suggestions.

### Use cases

- **SEO keyword research:** build a long-tail keyword list for a topic in minutes, with question keywords for FAQ and blog briefs.
- **YouTube SEO:** find the titles and phrases people type into YouTube, then compare them with Google.
- **Amazon and ecommerce:** collect the product terms shoppers use on each marketplace for listings, ads and backend keywords.
- **Content planning:** the question words mode gives "how", "what", "why" and "can" topics ready to turn into articles.
- **Local and international SEO:** repeat a seed across countries and languages to see how demand differs.
- **Market research and ads:** see what is trending around a brand, competitor or product name, and build negative and positive keyword lists.
- **Data for AI agents:** feed a seed into an agent or n8n flow and get a clean list of related queries back.

### How it compares with a SERP scraper

This is not a search results scraper. It does not load result pages, so it never needs a proxy, a browser or a captcha solver, and it does not return URLs or ads. It returns only the suggestion lists, which is exactly what keyword research needs and is why a row costs a fraction of a cent.

### Limits

- Autocomplete lists change over time and by region. Two runs on different days can differ. That is the point of the data.
- Each engine returns about 4 to 15 suggestions per query. Use A-Z, questions and prepositions to go deeper.
- Search volume and keyword difficulty are not included. Autocomplete shows what people type, not how many people type it.
- An engine can occasionally slow down or refuse a request. The Actor retries, and if an engine does not answer at all it is skipped and listed in the run `OUTPUT` and warnings instead of failing the run.
- Amazon suggestions use the marketplace matching your country code. Countries without an Amazon marketplace use the US one.
- Very large runs stop cleanly before the time limit and report in `OUTPUT` how many queries were not asked.

### Pricing and cost control

Pay per suggestion: **$0.0009 per suggestion on the free plan, $0.000554 on the Gold plan** (Bronze $0.000839, Silver $0.000715), plus a $0.00005 start fee per run. That is $0.90 per 1,000 suggestions on the free plan.

| Plan | Per suggestion | Per 1,000 |
|---|---|---|
| Free | $0.0009 | $0.90 |
| Bronze | $0.000839 | $0.84 |
| Silver | $0.000715 | $0.72 |
| Gold and above | $0.000554 | $0.55 |

You only pay for rows you receive. Use **Max suggestions** or Apify's **Maximum cost per run** to cap spend; the run stops cleanly at the limit. Duplicates are removed by default, so you are not charged for the same keyword twice.

### Integrations and scheduling

Run it on a schedule to track how autocomplete for a brand or topic changes week by week, then send results to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations, or call it through the REST API and the Python and JavaScript clients.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~keyword-suggestions-autocomplete/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"seeds":["coffee maker"],"engines":["google","bing"],"expansions":["plain","alphabet"],"maxResults":200}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/keyword-suggestions-autocomplete").call(run_input={"seeds": ["coffee maker"], "engines": ["google", "youtube"], "expansions": ["plain", "questions"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["suggestion"], row.get("engine"), row.get("rank"))
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/keyword-suggestions-autocomplete`, paste the input JSON, then map the dataset items to your sheet.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/keyword-suggestions-autocomplete` to Claude, Cursor or any MCP client, and your agent can run this Actor as a tool.

### Fair use and legal

The Actor calls the public suggestion endpoints that search boxes use. It does not log in, scrape result pages or collect personal data. Autocomplete suggestions are short phrases generated from aggregated queries. Follow each engine's terms for how you use the data. This is an independent tool, not affiliated with Google, YouTube, Microsoft, Amazon or DuckDuckGo.

### FAQ

**Do I need an API key or a proxy?** No. There is no login, key or proxy.

**Which engine should I start with?** Google for general keywords, YouTube for video topics, Amazon for product terms. Bing and DuckDuckGo add a second opinion, and merged mode shows where they agree.

**How many suggestions will I get?** Roughly 8 to 15 per query per engine. A seed with A-Z and question expansion on three engines usually returns 700 to 1,300 unique rows.

**Does it return search volume?** No. It returns the suggestions and where each ranks. Pair it with a trends or volume source if you need numbers.

**Can I use a different country or language?** Yes. Set `country` (for example de) and `language` (for example de). Amazon switches to that marketplace.

**Why do I get fewer rows than expected?** Duplicates are removed by default, an engine returned fewer suggestions for a rare seed, or you hit **Max suggestions**.

**Why was an engine skipped?** If an engine does not answer six times in a row with no successes it is skipped for the run, and the warning is saved in `OUTPUT`.

### Support

Seeing odd results for a seed, country or engine? Open an issue on the Issues tab with the run URL and the seed.

### Related actors

- [YouTube Video Scraper](https://apify.com/transparent_meteorite/youtube-video-scraper) to pull the videos behind the YouTube keywords you found.
- [Technical SEO Audit](https://apify.com/transparent_meteorite/technical-seo-page-audit) to check the pages you plan to rank for these keywords.
- [Google SERP Real URLs Scraper](https://apify.com/transparent_meteorite/google-search-results-scraper) to see who ranks for a keyword today.
- [Amazon Product Sales Signals](https://apify.com/transparent_meteorite/amazon-product-search) to test the Amazon terms against real product demand.

### Changelog

- **0.1**: First private build. Five engines plus Google Shopping and Images, A-Z, 0-9, question and preposition expansion, merged and deduped modes.

# Actor input Schema

## `seeds` (type: `array`):

One word or phrase per line. Each seed is expanded and sent to every engine you pick.

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

Which autocomplete engines to ask. Amazon uses the marketplace of the country below.

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

How each seed is expanded into queries. A-Z adds 26 queries per seed, questions 14, prepositions 13, digits 10.

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

Two-letter country code, for example us, gb, de, fr, jp. Sets the Google region, Bing market and Amazon marketplace.

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

Language code, for example en, de, fr, es, ja.

## `mergeEngines` (type: `boolean`):

One row per unique suggestion with an engines list, how many engines returned it and its best rank. Off gives one row per engine and suggestion.

## `removeDuplicates` (type: `boolean`):

Return each suggestion once (per engine, or across engines when merged). Turn off to keep every hit from every query.

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

Hard cap on rows returned for the whole run. Rows are charged, so this also caps your cost. The prefilled 300 keeps the demo cheap; raise it for a full research run.

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

How many autocomplete calls run at once. Lower it if an engine slows down.

## Actor input object example

```json
{
  "seeds": [
    "coffee maker"
  ],
  "engines": [
    "google",
    "youtube",
    "bing"
  ],
  "expansions": [
    "plain",
    "alphabet"
  ],
  "country": "us",
  "language": "en",
  "mergeEngines": false,
  "removeDuplicates": true,
  "maxResults": 300,
  "concurrency": 6
}
```

# Actor output Schema

## `suggestions` (type: `string`):

No description

# 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 maker"
    ],
    "engines": [
        "google",
        "youtube",
        "bing"
    ],
    "expansions": [
        "plain",
        "alphabet"
    ],
    "country": "us",
    "language": "en",
    "maxResults": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/keyword-suggestions-autocomplete").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 maker"],
    "engines": [
        "google",
        "youtube",
        "bing",
    ],
    "expansions": [
        "plain",
        "alphabet",
    ],
    "country": "us",
    "language": "en",
    "maxResults": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/keyword-suggestions-autocomplete").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 maker"
  ],
  "engines": [
    "google",
    "youtube",
    "bing"
  ],
  "expansions": [
    "plain",
    "alphabet"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 300
}' |
apify call transparent_meteorite/keyword-suggestions-autocomplete --silent --output-dataset

```

## MCP server setup

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

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/BDHwSms3o6OGCPyYn/builds/tykmqeRDd0d7luqhb/openapi.json
