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

Autocomplete keyword ideas from Google, YouTube, Bing, DuckDuckGo and Amazon in one run: each keyword expanded a-z, with question and comparison modifiers, for 36 countries. Deduplicated, with position and relevance. $0.001 per keyword.

- **URL**: https://apify.com/dtkfoundry/keyword-autocomplete.md
- **Developed by:** [DTK Foundry](https://apify.com/dtkfoundry) (community)
- **Categories:** SEO tools, Marketing, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 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 Scraper: Google, YouTube, Bing, Amazon

Keyword ideas from the autocomplete boxes of Google, YouTube, Bing, DuckDuckGo and Amazon, in one run. Each
keyword is widened the way keyword tools do it (keyword + a ... z, question words, "for / with / vs ..."), every
suggestion is de-duplicated, and you get where it came from: what was typed, its position in the list and Google's
relevance score. 36 countries, any language.

- **Many ideas per keyword.** "standing desk" with all three expansions gave 619 unique ideas on Google, 475 on
  Bing, 408 on YouTube, 294 on DuckDuckGo and 282 on Amazon (live run, 2026-10-22), in under 5 seconds.
- **Reliable.** Tested on 200 varied keyword lookups across all five engines and 10 countries: 5,400 of 5,400
  requests answered, no retries needed (the only empty results were English keywords on Amazon UK/DE/FR/ES,
  where Amazon itself suggests nothing). Then 40 keywords x 5 engines with every expansion, as one run:
  200 of 200 answered, 79,303 unique suggestions, 0 failed.
- **Five engines, one format.** Pick any mix. Amazon uses the store of the country you choose (12 stores).
- **Clean keyword output.** Google's website shortcuts ("http://...") are left out; every row is a search
  phrase people actually type.
- **$0.10 per 1,000 suggestions.** Pay only for unique suggestions delivered, and cap how many you want per
  keyword. Keywords that fail, or return nothing, are never charged.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | `[]` | One keyword or phrase per line. Empty = a free format example. |
| `engines` | array | `["google"]` | Any of `google`, `youtube`, `bing`, `duckduckgo`, `amazon`. |
| `expansions` | array | `["alphabet"]` | `alphabet` (keyword + a ... z), `questions` (how / what / why ... + keyword), `prepositions` (keyword + for / with / without / vs / near / to / like / or / and). Empty = the keyword alone. |
| `maxSuggestionsPerKeyword` | integer | `0` | Cap per keyword and engine (0 = no limit). The keyword's own suggestions come first, then each expansion in order. |
| `country` | string | `us` | Two-letter country code: us, gb, ca, au, nz, ie, in, sg, za, de, at, ch, fr, be, nl, es, mx, ar, co, cl, it, pt, br, pl, se, dk, no, fi, jp, kr, tr, id, ph, my, ae, sa. |
| `language` | string | country's own | Two-letter language code for Google, YouTube and Bing (`en`, `de`, `es` ...). |
| `outputFormat` | string | `suggestions` | `suggestions` = one row per unique suggestion; `grouped` = one row per keyword and engine with a list. |

```json
{
    "keywords": ["coffee maker", "standing desk"],
    "engines": ["google", "youtube", "amazon"],
    "expansions": ["alphabet", "questions"],
    "country": "us"
}
```

### Output (one record per unique suggestion)

```json
{
    "status": "ok",
    "suggestion": "standing desk and walking pad combo",
    "keyword": "standing desk",
    "engine": "bing",
    "query": "standing desk and",
    "expansion": "prepositions",
    "position": 10,
    "relevance": 1291,
    "timesSeen": 1,
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-10-22T17:15:57+00:00"
}
```

- `query` is what was typed into the box and `position` the suggestion's place in that list (1 = top).
  `expansion` says which expansion produced it (`keyword` for the keyword itself).
- `relevance` is the engine's own score where it gives one (Google, YouTube and Bing); higher = shown higher.
  Amazon and DuckDuckGo give `null`.
- `timesSeen` counts how many of the keyword's lookups returned the same suggestion. Ideas seen in many lookups
  are the strongest.
- Suggestions are de-duplicated per keyword and engine, ignoring case. The same idea from two engines appears
  once for each engine.
- In `grouped` mode each record has `suggestions` (a list in first-seen order), `count`, `queries` and
  `queriesAnswered`.
- A keyword with no suggestions gives one record with `status: "no-results"`; one that could not be looked up
  gives `status: "failed"` and an `error`. Neither is charged.

### Pricing

Pay per event, no subscription.

| Event | Price | When it is charged |
|---|---|---|
| Suggestion | **$0.0001** | Once per unique suggestion delivered ($0.10 per 1,000), in either output format. |

What a keyword typically costs on one engine (live run, 2026-10-22, US):

| Expansion | Suggestions per keyword | Cost per keyword |
|---|---|---|
| Keyword alone | 10-15 | about $0.0013 |
| Alphabet (a-z) | Google ~250, Bing ~200, YouTube ~170, DuckDuckGo ~130, Amazon ~100 | $0.01-0.025 |
| Alphabet + questions + prepositions | Google ~600, Bing ~490, YouTube ~425, DuckDuckGo ~280, Amazon ~185 | $0.02-0.06 |

Use `maxSuggestionsPerKeyword` to set a hard cost per keyword (100 = at most $0.01). Keywords with no suggestions
or that could not be looked up are not charged. If a few expansion lookups fail after retries, you get (and pay
for) only the suggestions that came back. Set a maximum charge in the run options and the actor stops before it
would go over. Apify's standard run-start event adds $0.00005 per run.

### Limits, stated plainly

- These are autocomplete suggestions, not search volumes. They show what people type, in the order each engine
  ranks them, but not how often.
- Question and preposition words are English. For other languages use the alphabet expansion, which works in any
  language.
- Google may mix in ideas tied to the location of the server it is asked from (a city name). The country setting
  steers the answers but does not pin them to one city.
- Amazon has no suggest service for India on this endpoint, so Amazon covers 12 stores: us, gb, de, fr, ca, es,
  it, nl, jp, mx, au, br.
- Up to 1,000 keywords per run.
- Public data only: no login, no personal data.

### Privacy

Only the keywords you give are sent to the engines you choose. Results are stored only in your run's dataset.
The actor runs with limited permissions and reads nothing else in your account.

# Actor input Schema

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

One keyword or phrase per line ("coffee maker", "how to learn spanish"). Each keyword is looked up on every engine you pick. Leave empty for a free format example.

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

Where the suggestions come from. Google = Google Search, YouTube = YouTube search box, Amazon = the marketplace of the country below.

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

How each keyword is widened into more lookups. Alphabet: keyword + a ... z (27 lookups, about 150-300 unique ideas on Google). Questions: how / what / why ... + keyword. Prepositions: keyword + for / with / vs / near ... Question and preposition words are English. None selected = the keyword alone (about 10-15 ideas).

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

Caps the cost: each unique suggestion is one charged result. 0 = no limit (a-z on Google gives about 150-300). The first ones found are kept: the keyword's own suggestions, then each expansion in order.

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

The country the engines answer for. Amazon has a store in: United States, United Kingdom, Germany, France, Canada, Spain, Italy, Netherlands, Japan, Mexico, Australia, Brazil.

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

2-letter language code (en, de, es ...) for Google, YouTube and Bing. Empty = the country's main language.

## `outputFormat` (type: `string`):

Suggestions: one row per unique suggestion (best for CSV and spreadsheets). Grouped: one row per keyword and engine with all its suggestions in a list.

## Actor input object example

```json
{
  "keywords": [
    "coffee maker",
    "standing desk"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ],
  "expansions": [
    "alphabet",
    "questions"
  ],
  "maxSuggestionsPerKeyword": 0,
  "country": "us",
  "outputFormat": "suggestions"
}
```

# Actor output Schema

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

Every suggestion with the keyword, engine, the text typed, position and relevance.

## `resultsCsv` (type: `string`):

The same suggestions as CSV.

# 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 maker",
        "standing desk"
    ],
    "engines": [
        "google",
        "youtube",
        "amazon"
    ],
    "expansions": [
        "alphabet",
        "questions"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dtkfoundry/keyword-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 = {
    "keywords": [
        "coffee maker",
        "standing desk",
    ],
    "engines": [
        "google",
        "youtube",
        "amazon",
    ],
    "expansions": [
        "alphabet",
        "questions",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dtkfoundry/keyword-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 '{
  "keywords": [
    "coffee maker",
    "standing desk"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ],
  "expansions": [
    "alphabet",
    "questions"
  ]
}' |
apify call dtkfoundry/keyword-autocomplete --silent --output-dataset

```

## MCP server setup

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