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

Every autocomplete suggestion for your keywords from Google, YouTube, Bing, Amazon and DuckDuckGo as JSON: suggestion, engine, rank and the expanded query that produced it. Alphabet and question expansion, no API key. From $0.30 per 1,000 suggestions.

- **URL**: https://apify.com/subimpact/keyword-autocomplete-suggestions.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** SEO tools, E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 autocomplete suggestion scrapeds

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 Autocomplete Suggestions API (Google, YouTube, Bing, Amazon, DuckDuckGo)

**Every autocomplete suggestion for your keywords, as JSON.** Give the actor a list of seed
keywords and it queries the public autocomplete endpoints of up to five engines — Google Search,
YouTube, Bing, Amazon and DuckDuckGo — and returns one clean row per suggestion, with the engine,
its rank and the expanded query that produced it.

- **No start fee. $0.30 per 1,000 suggestions** ($0.0003 per suggestion delivered).
- **No API key, no browser.** Plain HTTP against the engines' public suggestion endpoints.
- **5 engines.** Google by default; add YouTube, Bing, Amazon and DuckDuckGo with one input field.
- **Expansion.** Query the seed alone, or also `seed + a–z + 0–9` (alphabet), or also the seed plus
  `who/what/where/when/why/how/can/is/are/does` and `vs/for/near` (questions) to pull suggestions
  the plain seed never returns.
- **Up to 100,000 suggestions per run**, 5 keyword/engine tasks in parallel by default.

### What you get

One dataset item per suggestion. Useful for keyword research, store listing and ad-group ideas,
YouTube topic discovery, Amazon product-search terms, question mining for content briefs, and
tracking how suggestions change over time.

| Field | Meaning |
| --- | --- |
| `seed` | The keyword from your input |
| `query` | The expanded query actually sent (the seed, or `coffee a`, `how coffee`, `coffee vs`, …) |
| `engine` | `google`, `youtube`, `bing`, `amazon` or `duckduckgo` |
| `suggestion` | The suggestion text, exactly as the engine returned it |
| `position` | 1-based rank in that engine's response for that query (1 = top suggestion) |
| `language`, `country` | The locale used for the request |
| `scrapedAt` | ISO-8601 timestamp of the request that produced the row |
| `status` | `ok` for a suggestion row; `empty` / `error` for the free diagnostic rows described below |
| `error` | Why an empty/error row was delivered; `null` on `ok` rows |

### Input

```json
{
  "keywords": ["coffee", "running shoes"],
  "engines": ["google", "youtube", "bing"],
  "language": "en",
  "country": "us",
  "expand": "alphabet",
  "maxSuggestionsPerKeyword": 200,
  "maxItems": 1000,
  "dedupe": true,
  "concurrency": 5
}
```

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `keywords` | array | — (required) | Seed keywords. Trimmed, de-duplicated, up to 10,000 per run. |
| `engines` | array | `["google"]` | Any of `google`, `youtube`, `bing`, `amazon`, `duckduckgo`. |
| `language` | string | `en` | `hl` for Google/YouTube, `setlang` for Bing, `accept-language` for Amazon. Accepts `de`, `ja`, `pt-BR`, … DuckDuckGo's autocomplete has no language parameter, so it returns its global list (the value is still written to every row). |
| `country` | string | `us` | Two-letter code. `gl` for Google/YouTube and the Amazon marketplace selector. |
| `expand` | string | `none` | `none`, `alphabet` (37 queries per keyword/engine) or `questions` (14 queries per keyword/engine). |
| `maxSuggestionsPerKeyword` | integer | `200` | Cap per keyword **and** engine, 1–1,000. |
| `maxItems` | integer | `1000` | Row cap for the whole run, 1–100,000. Counts delivered suggestions; free `empty`/`error` rows do not use it up. |
| `dedupe` | boolean | `true` | Deliver a suggestion once per keyword and engine even if a later expanded query returns it again. |
| `concurrency` | integer | `5` | Keyword/engine tasks in parallel, 1–20. Each task sends its expanded queries one after another. |
| `proxyConfiguration` | object | off | Optional Apify Proxy. Plain HTTP works; turn it on only if an engine starts rate-limiting your runs. |

A default run (the two pre-filled keywords on Google, no expansion) returns roughly 20 suggestions
and costs well under a cent.

### Output

One dataset item per suggestion. This is a real row from a live run (Google, `country: "us"`):

```json
{
  "seed": "coffee",
  "query": "coffee",
  "engine": "google",
  "suggestion": "coffee near me",
  "position": 1,
  "language": "en",
  "country": "us",
  "scrapedAt": "2026-11-15T09:08:50.640Z",
  "status": "ok",
  "error": null
}
```

A query that the engine answers with nothing, or a request that fails, is delivered as a free
diagnostic row — `suggestion` and `position` are `null` and nothing is charged for it (shape
example):

```json
{
  "seed": "coffee",
  "query": "coffee qq",
  "engine": "google",
  "suggestion": null,
  "position": null,
  "language": "en",
  "country": "us",
  "scrapedAt": "2026-11-15T09:08:11.420Z",
  "status": "empty",
  "error": "google returned no autocomplete suggestions for \"coffee qq\"."
}
```

### Engines and expansion

| Engine | Endpoint used | Notes |
| --- | --- | --- |
| `google` | `suggestqueries.google.com/complete/search?client=firefox` | Google Search suggestions; honours `hl` / `gl`. |
| `youtube` | same endpoint with `ds=yt` | YouTube search suggestions. |
| `bing` | `api.bing.com/osjson.aspx` | Bing suggestions; honours `setlang`. |
| `amazon` | `completion.amazon.<tld>/api/2017/suggestions` | Amazon product-search suggestions. The marketplace and its id must match, so `country` picks the pair: **US** (`ATVPDKIKX0DER`), **GB** (`A1F83G8C2ARO7P`), **DE** (`A1PA6795UKMFR9`), **JP** (`A1VC38T7YXB528`), **IN** (`A21TJRUUN4KGV`). Any other country uses the US marketplace. |
| `duckduckgo` | `duckduckgo.com/ac/?type=list` | DuckDuckGo autocomplete; no locale parameter. |

`expand: "alphabet"` sends the seed and then `coffee a` … `coffee z`, `coffee 0` … `coffee 9`
(`coffee a` returns `coffee advent calendar`, `coffee and peppers`, …).
`expand: "questions"` sends the seed and then `who coffee` … `does coffee`, plus `coffee vs`,
`coffee for`, `coffee near` (`how coffee` returns `how coffee is made`, `how coffee was discovered`, …).
Every row records which of those queries produced the suggestion, so you can tell a seed suggestion
from a long-tail one.

### Billing

- **$0.30 per 1,000 suggestions** — $0.0003 for each suggestion row delivered.
- **No start fee.** You are not charged for the requests themselves, for empty results, or for
  errors. Every row with `status: "empty"` or `status: "error"` is free, which means a run against a
  blocked engine costs nothing.
- `maxItems` (and the run's max charge) stops the run cleanly; the status message reports how many
  rows were actually delivered.

### Notes and limits

- These are the engines' public suggestion endpoints, so the suggestions are exactly what each
  engine would show a user, including that engine's own locale and ranking behaviour. They are not
  search volumes; no search-volume data is included.
- Bing's endpoint answers `HTTP 204` with an empty body to desktop-browser user agents from some
  networks; the actor sends the mobile user agent Bing accepts (verified live 2026-11-15).
- Amazon's completions are marketplace-specific; the India marketplace (`completion.amazon.in`)
  answered `HTTP 502` during our live checks on 2026-11-15, so India is mapped but not verified end
  to end. A failing marketplace produces free `error` rows, never charges.
- With `concurrency: 5` and `expand: alphabet` a single keyword sends 37 requests per engine. Each
  keyword/engine task sends its queries one after another, so a run only ever has about
  `concurrency` requests in flight however many expansion queries it has. If an engine ever starts
  refusing requests, lower `concurrency`, or enable Apify Proxy in `proxyConfiguration`.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

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

Seed keywords to collect autocomplete suggestions for, e.g. \["coffee", "running shoes"]. Duplicates and blank entries are dropped. Up to 10,000 per run.

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

Which autocomplete engines to query: google (Google Search), youtube (YouTube), bing (Bing), amazon (Amazon product search) or duckduckgo (DuckDuckGo). Default \["google"]. Pick several to compare what each engine suggests for the same keyword.

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

Interface language for the suggestions, e.g. en, de, es, ja, pt-BR. Sent as hl to Google/YouTube, setlang to Bing and accept-language to Amazon. DuckDuckGo's autocomplete ignores it (the value is still written to every row).

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

Two-letter country code for the suggestions, e.g. us, gb, de, jp, my. Sent as gl to Google/YouTube and used to pick the Amazon marketplace (US, GB, DE, JP and IN have their own; other countries fall back to the US marketplace). DuckDuckGo's autocomplete ignores it.

## `expand` (type: `string`):

none queries only the seed. alphabet also queries the seed plus a-z and 0-9 (37 queries per keyword and engine). questions also queries the seed plus who/what/where/when/why/how/can/is/are/does and vs/for/near (14 queries per keyword and engine). Expansion is how you harvest suggestions the plain seed never returns.

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

How many suggestions to keep for each keyword on each engine (1-1,000, default 200). Expansion stops for that keyword/engine once the limit is reached.

## `maxItems` (type: `integer`):

Maximum number of suggestion rows delivered in one run (1-100,000, default 1,000). Counts delivered suggestions only: free empty/error status rows do not use up the cap. Default 1,000 costs $0.30.

## `dedupe` (type: `boolean`):

When true (default), a suggestion that an engine already returned for the same keyword is delivered once, even when a later expanded query returns it again (e.g. "coffee" from both "coffee" and "coffee shop"). Duplicates are counted in the run log.

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

How many keyword/engine tasks run in parallel (1-20, default 5). Each task sends its expanded queries one after another (up to 37 requests with alphabet expansion), so 5 is already gentle on the engines' rate limits.

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

Optional. Plain HTTP works and is the default; switch on Apify Proxy if an engine starts rate-limiting your runs or if you need suggestions as seen from another country.

## Actor input object example

```json
{
  "keywords": [
    "coffee",
    "running shoes"
  ],
  "engines": [
    "google"
  ],
  "language": "en",
  "country": "us",
  "expand": "none",
  "maxSuggestionsPerKeyword": 200,
  "maxItems": 1000,
  "dedupe": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per suggestion: seed, query (the expanded query sent), engine (google/youtube/bing/amazon/duckduckgo), suggestion, position (1-based rank in that engine's response), language, country, scrapedAt and status. Queries that returned nothing or failed are delivered as free rows with suggestion and position null, status empty/error and a reason in error — they are never charged.

# 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",
        "running shoes"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/keyword-autocomplete-suggestions").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",
        "running shoes",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/keyword-autocomplete-suggestions").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",
    "running shoes"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call subimpact/keyword-autocomplete-suggestions --silent --output-dataset

```

## MCP server setup

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

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/8XJyfQUnzOgeXMsvN/builds/Z2QAc888i9HeeeZkT/openapi.json
