# Autocomplete Keyword Scraper - Google, YouTube, Bing (`mmdincer/autocomplete-keyword-scraper`) Actor

Scrape keyword suggestions from Google, YouTube and Bing autocomplete for SEO research. Enter seed keywords, get deduplicated rows with engine, rank, intent and question flags. A-Z/0-9 expansion, 29 languages. No search volume. No login or browser. Not affiliated with Google, YouTube or Microsoft.

- **URL**: https://apify.com/mmdincer/autocomplete-keyword-scraper.md
- **Developed by:** [Muhammet Mustafa Dincer](https://apify.com/mmdincer) (community)
- **Categories:** SEO tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.56 / 1,000 keyword suggestion rows

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

![Autocomplete Keyword Scraper: Google, YouTube and Bing autocomplete suggestions for the seed keyword coffee grinder, shown as a search box with a suggestion list](https://api.apify.com/v2/key-value-stores/Iraub1Fw8gpUk3az3/records/keyword-banner.png?signature=1vBmDYwbiDiS0ru1JLVV1)

### What is Autocomplete Keyword Scraper?

**Autocomplete Keyword Scraper** turns a few seed keywords into hundreds of **keyword suggestions** taken from the search boxes of **Google, YouTube and Bing** — in one run, without an API key, a login or a browser. Type your keywords, click **Start**, and get a clean table: every unique suggestion once, with the engines that returned it, its position, a rule-based **search intent** label and ready-to-filter flags.

It does **not** return search volume, CPC or keyword difficulty: autocomplete lists contain no such data. Use it to discover phrases, then size them with a volume tool if you need numbers.

Because it runs on the Apify platform, you also get API access, scheduling, webhooks and integrations (Google Sheets, Make, Zapier, n8n), and you can call it from AI agents through the Apify MCP server.

You may also know this kind of tool as a Google Suggest scraper, an autosuggest or query suggestion tool, or a keyword idea generator.

### At a glance

| | |
|---|---|
| **Does** | Collects autocomplete suggestions for your seed keywords from Google, YouTube and Bing, deduplicates them and labels them |
| **Input** | `keywords` (required, up to 500 seed phrases). Optional: `engines`, `country`, `language`, expansion switches, `maxResults` |
| **Output** | One dataset row per unique suggestion: `keyword`, `seed`, `engines`, `engineCount`, `position`, `intent`, `isQuestion`, `containsSeed`, `wordCount`, `country`, `language` and more (see below) |
| **Engines** | Google, YouTube, Bing |
| **Reach** | 48 countries, 29 languages |
| **Needs** | No login, no API key, no browser. Apify Proxy is optional |
| **Speed** | The prefilled example (1 keyword, 100 rows) finishes in seconds |
| **Pricing** | Pay per event: a small start fee plus a price per result row. Cap a run with `maxResults` or the run's maximum charge |
| **Does not** | Search volume, CPC, difficulty, SERP results, rank tracking, People Also Ask, Google Trends, Amazon, TikTok or App Store suggestions |

### When should you use this Actor?

Use it when you (or the AI agent you are building) need to:

- turn one or a few seed keywords into many long-tail keyword and question ideas;
- see what Google, YouTube and Bing each suggest for the same phrase, and which phrases they agree on;
- compare suggestions between countries or languages;
- get a clean, deduplicated, labelled table instead of raw suggestion lists.

Pick a different tool when you need search volume, CPC or difficulty numbers, the actual search results page, ranking positions of a website, or suggestions from shops, social networks or app stores. This Actor does none of those.

### What can you do with it?

- **SEO and content research**: find long-tail keywords and questions people actually type (`expandAlphabet`, `expandQuestions`).
- **Video SEO**: see what YouTube suggests for a topic and which phrases Google and YouTube agree on.
- **Local and international research**: run the same keyword for 48 countries in 29 languages and compare what each market sees.
- **Ad and product ideas**: filter `intent = transactional` or `commercial` to get purchase-style phrases.

### Which search engines are supported?

| Engine | What you get | Notes |
|---|---|---|
| **Google** | Google search box suggestions for your country and language | Marks suggestions that Google itself flags as a website (used for the `navigational` label) |
| **YouTube** | YouTube search box suggestions | Useful for video topics and tutorials |
| **Bing** | Bing search box suggestions for the market built from your language and country | Often overlaps with Google; `engineCount` shows the overlap |

DuckDuckGo, Amazon and the App Store are not offered: their robots.txt files disallow these suggestion endpoints.

### What data can you extract?

Each row is one unique keyword (or one keyword per engine, if you choose **Per engine** output).

| Field | Example | Meaning |
|---|---|---|
| `keyword` | `coffee grinder reviews` | The suggestion, lower-cased, single spaces |
| `seed` | `coffee grinder` | The keyword you entered |
| `engines` / `engineCount` | `["google","youtube","bing"]` / `3` | Which engines suggested it, and how many |
| `position` / `positions` | `3` / `{"google":14,"youtube":3,"bing":8}` | Best rank per engine (1 = first suggestion) |
| `query` / `expansion` | `coffee grinder a` / `alphabet` | The text sent to the engine and how it was built |
| `intent` / `intentSignals` | `commercial` / `["reviews"]` | Rule-based intent label and the words that triggered it |
| `isQuestion` | `false` | Phrased as a question |
| `containsSeed` | `true` | Every word of your keyword appears in the suggestion |
| `tokens` / `wordCount` | `["coffee","grinder","reviews"]` / `3` | Word split |
| `country` / `language` | `us` / `en` | Locale used for the request |

![Example output of Autocomplete Keyword Scraper: a table of keyword suggestions for "coffee grinder" with engines, best position, search intent and question flag](https://api.apify.com/v2/key-value-stores/Iraub1Fw8gpUk3az3/records/keyword-sample-output.png?signature=1wZxMyEO4NHdHhvR9HU2x)

*The table above is real output of one run: seed `coffee grinder`, Google + YouTube + Bing, US / English, a–z expansion on.*

### How to get keyword suggestions (step by step)

1. Open the Actor and click **Try for free**.
2. Enter one or more **Keywords**. A prefilled example is included.
3. Pick the **Engines**, **Country** and **Language**.
4. Switch on the **Expansion** options you want. The a–z expansion is what turns about 10 suggestions into hundreds.
5. Set **Max results** (keep it low for your first run) and click **Start**.
6. Download the dataset as JSON, CSV or Excel, or read it through the API. A short report with per-engine request counts is saved as `RUN_SUMMARY`.

### Input example

```json
{
  "keywords": ["coffee grinder", "espresso machine"],
  "engines": ["google", "youtube", "bing"],
  "country": "us",
  "language": "en",
  "expandAlphabet": true,
  "expandQuestions": true,
  "maxResults": 500
}
```

### Output example

```json
{
  "keyword": "coffee grinder reviews",
  "seed": "coffee grinder",
  "engine": null,
  "engines": ["google", "youtube", "bing"],
  "engineCount": 3,
  "position": 3,
  "positions": { "google": 14, "youtube": 3, "bing": 8 },
  "query": "coffee grinder",
  "expansion": "direct",
  "intent": "commercial",
  "intentSignals": ["reviews"],
  "isQuestion": false,
  "containsSeed": true,
  "tokens": ["coffee", "grinder", "reviews"],
  "wordCount": 3,
  "language": "en",
  "country": "us",
  "fetchedAt": "2026-11-02T21:32:24.811Z"
}
```

### How are search intent labels decided?

Labels come from **fixed word lists, not machine learning**. A keyword gets the label of the first group that matches, in this order:

1. **navigational** — login or sign-in words, "official site", a web address, or a suggestion that Google itself marks as a website.
2. **transactional** — buy, order, price, cost, cheap, discount, coupon, deal, near me, shipping, rent, book, download, subscribe, free trial, and well-known shop names (Amazon, Walmart, eBay and a few others).
3. **commercial** — best, top, review(s), vs, compare, alternative, recommended, worth it, pros and cons.
4. **informational** — question words (how, what, why …), guide, tutorial, tips, meaning, examples and similar.

English lists always apply. German, Spanish, French, Italian, Portuguese, Dutch and Turkish have their own extra lists, used when you pick that language. **If no word matches, the label is `informational` and `intentSignals` is empty.** Many suggestions are plain product or brand phrases without any intent word, so filter on a non-empty `intentSignals` when you want only the labels that a rule actually triggered. Words can be ambiguous ("top gun" counts as commercial), so treat the label as a quick filter, not as ground truth.

### How much does it cost to get keyword suggestions?

The Actor uses **pay-per-event** pricing: a small start fee plus a price per result row. Nothing else is billed to you for this Actor, and the price drops with your Apify plan.

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| Actor start | $0.002 | $0.002 | $0.002 | $0.002 |
| Result row | $0.0008 | $0.0007 | $0.00063 | $0.00056 |

Example: 1,000 keyword rows cost about **$0.70** on the Bronze plan (**$0.80** on the Free plan), plus the start fee. The prefilled example (100 rows) costs at most about **$0.08** on the Free plan. The Apify Free plan includes $5 of monthly credit, which is enough for several thousand rows. In merged mode you pay for each unique keyword once, not once per engine. Use **Max results** and **Max suggestions per engine** to cap the cost of a run — the Actor also stops when the spending limit you set for the run is reached.

### Tips for best results

- Start with the a–z expansion only, then add questions or prepositions for the keywords that matter.
- Use specific two- to four-word seeds. One very broad word returns a broad, noisy list; use `containsSeed = true` to drop loosely related suggestions.
- Google and Bing suggestions often overlap, so `engineCount` is a handy signal: phrases that several engines agree on are usually the safest long-tail picks.
- Run the same seeds for several countries to compare markets.
- If one engine starts answering with HTTP 429, the Actor slows down by itself, retries, and finally switches that engine off for the rest of the run while the others continue. Lower **Requests per second** or turn on Apify Proxy for the next run.

### Limits and good to know

- **Suggestions only, no search volume.** Autocomplete does not provide how often a phrase is searched, so this Actor cannot give volumes, CPC or difficulty.
- Suggestions are what each engine shows to an anonymous visitor at that moment. They change over time and by location, and they are not personalized.
- Intent labels are rule-based (see above). Question words for expansion exist for English, German, Spanish, French, Italian, Portuguese, Dutch and Turkish; other languages use English question words. The a–z expansion uses Latin letters.
- With a **Max results** limit, keywords are processed in the order you entered them and the run stops when the limit is reached.
- **Skip suggestions already delivered** (`onlyNew`) remembers phrases this Actor already wrote for the same country, language and engines, and leaves them out of later runs. Those rows are not charged. The lists are still read. A run where every suggestion was already seen finishes successfully and says so, instead of failing as an empty result.

### Use it from AI agents, the API and code

**Apify MCP server (ChatGPT, Claude, Cursor and other MCP clients).** Connect `https://mcp.apify.com`, search for this Actor with `search-actors` (for example `google autocomplete keywords`), read its input schema with `fetch-actor-details`, then run it with `call-actor`. Pass `mmdincer/autocomplete-keyword-scraper` as the Actor and keep the run small, for example `maxResults` 100 in the input and a spending cap in `callOptions` (`maxTotalChargeUsd`). `call-actor` returns the dataset ID, not the rows: read them with `get-dataset-items`. This Actor uses limited permissions, so it is not blocked from the MCP server.

Input an agent can send as is:

```json
{
  "keywords": ["standing desk"],
  "engines": ["google", "youtube"],
  "country": "us",
  "language": "en",
  "expandAlphabet": true,
  "expandQuestions": true,
  "maxResults": 100
}
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('mmdincer/autocomplete-keyword-scraper').call(
    { keywords: ['standing desk'], maxResults: 100 },
    { maxTotalChargeUsd: 0.5 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
import os
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(token=os.environ['APIFY_TOKEN'])
run = client.actor('mmdincer/autocomplete-keyword-scraper').call(
    run_input={'keywords': ['standing desk'], 'maxResults': 100},
    max_total_charge_usd=Decimal('0.5'),
)
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**HTTP (one request, returns the rows)**

```bash
curl -X POST "https://api.apify.com/v2/acts/mmdincer~autocomplete-keyword-scraper/run-sync-get-dataset-items?maxTotalChargeUsd=0.5" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["standing desk"], "maxResults": 100}'
```

You can also schedule the Actor to track how suggestions change over time, and send the dataset to Google Sheets, Make, Zapier, n8n or your own webhook.

### Is it legal to scrape autocomplete suggestions?

The Actor reads the **publicly served suggestion lists** that search boxes request while someone types. It does not log in and does not collect personal data. These suggestion endpoints are **unofficial and undocumented**: they are not an official API of Google, YouTube or Microsoft, they come with no service guarantee, their format can change without notice, and the providers can rate-limit or block automated requests. The terms of service of the search providers may restrict automated access, and you are responsible for using the results in line with them and with the laws that apply to you. This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google, YouTube or Microsoft. All trademarks belong to their owners.

**Trademarks.** Not affiliated with, endorsed by, or sponsored by Google, YouTube or Microsoft. Trademarks belong to their respective owners. Google, YouTube and Bing names and logos are used only to say which search engines the Actor reads; the icon shows their marks for the same purpose.

### FAQ

**Does it need an API key, cookies or a login?** No.

**Is there an official Google autocomplete API?** Google does not offer a documented one. This Actor reads the same public suggestion endpoints the search box uses; see "Is it legal to scrape autocomplete suggestions?" for the caveats.

**Does it return search volume?** No. Autocomplete has no volume data; see "Limits and good to know".

**How many suggestions can I get per keyword?** Each request returns up to about 10–15 suggestions. With the a–z expansion, a typical keyword gives a few hundred unique suggestions per engine; digits, questions and prepositions add more.

**Why did I get fewer results than expected?** The run stopped at **Max results** or **Max suggestions per engine**, the keyword is very narrow, or an engine was switched off after repeated failures. `RUN_SUMMARY` lists what happened per engine.

**Which countries and languages are supported?** 48 countries and 29 languages for the suggestion requests. Pick them in the input form.

**Can I get suggestions in Turkish, German, Spanish or another language?** Yes: set **Country** and **Language**. Question words and intent word lists exist for English, German, Spanish, French, Italian, Portuguese, Dutch and Turkish.

**Can an AI agent use this Actor?** Yes. It works through the Apify MCP server, the Apify API and the Apify clients; see "Use it from AI agents, the API and code". Keep `maxResults` low and set a maximum charge per run.

**How do I report a problem or ask for a feature?** Open an issue in the **Issues** tab and include a link to your run.

# Changelog

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

# Actor input Schema

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

Seed keywords, one per line, for example <code>coffee grinder</code>. Short phrases of two to four words work best. Each seed is expanded and sent to every selected engine. Up to 500 keywords per run, 100 characters each.

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

Which search boxes to query: Google, YouTube and/or Bing. In merged output mode each keyword appears once, with the list of engines that suggested it.

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

Country of the searcher (Google <code>gl</code>, Bing market). Suggestions differ by country.

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

Interface language of the searcher (Google <code>hl</code>). It also selects the question words and intent word lists used for expansion and labelling.

## `expandAlphabet` (type: `boolean`):

Also query <code>keyword a</code>, <code>keyword b</code> ... <code>keyword z</code>. This is what turns about 10 suggestions into hundreds. Adds 26 requests per keyword and engine.

## `expandDigits` (type: `boolean`):

Also query <code>keyword 0</code> ... <code>keyword 9</code>. Useful for years, versions and quantities. Adds 10 requests per keyword and engine.

## `expandQuestions` (type: `boolean`):

Also query <code>how keyword</code>, <code>why keyword</code>, <code>can keyword</code> and similar, in the selected language (English, German, Spanish, French, Italian, Portuguese, Dutch, Turkish; other languages use English question words). Adds about 12 requests per keyword and engine.

## `expandModifiers` (type: `boolean`):

Also query <code>keyword for</code>, <code>keyword with</code>, <code>keyword vs</code>, <code>keyword near</code>, <code>keyword alternative</code> and similar, in the selected language. Adds about 14 requests per keyword and engine.

## `maxSuggestionsPerEngine` (type: `integer`):

Upper limit of unique suggestions kept from each engine for each keyword. Lower it to get a quick sample.

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

Upper limit of result rows for the whole run, across all keywords. The run stops when it is reached. You pay per result row, so this is also your cost cap. Keep it low (for example 100) for a first run or when an AI agent starts the Actor.

## `onlyNew` (type: `boolean`):

When on, suggestions this Actor already wrote for the same country, language and engines are left out of the dataset and are not charged. The suggestion lists are still read, so a repeat run spends the requests but you only pay for phrases that are new, up to Max results. Off by default, so a run without it returns the same list as before.

## `outputMode` (type: `string`):

<b>Merged</b>: one row per unique keyword, with the list of engines that suggested it. <b>Per engine</b>: one row per keyword and engine (more rows, so a higher cost for the same keywords).

## `requestsPerSecond` (type: `integer`):

Maximum request rate to each suggestion host. The Actor slows down by itself when it receives HTTP 429. Lower this value if an engine keeps rejecting requests.

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

Optional. Requests go out directly by default. Turn on Apify Proxy only if an engine blocks the Actor (HTTP 429 or 403). Each request is tiny, so proxy traffic stays small.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder",
    "espresso machine"
  ],
  "engines": [
    "google",
    "youtube",
    "bing"
  ],
  "country": "us",
  "language": "en",
  "expandAlphabet": true,
  "expandDigits": false,
  "expandQuestions": false,
  "expandModifiers": false,
  "maxSuggestionsPerEngine": 100,
  "maxResults": 100,
  "onlyNew": false,
  "outputMode": "merged",
  "requestsPerSecond": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per unique keyword (or per keyword and engine in per-engine mode).

## `summary` (type: `string`):

Per-engine request counts, failures, warnings and the reason the run stopped.

# 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 grinder"
    ],
    "engines": [
        "google",
        "youtube",
        "bing"
    ],
    "country": "us",
    "language": "en",
    "expandAlphabet": true,
    "expandDigits": false,
    "expandQuestions": false,
    "expandModifiers": false,
    "maxSuggestionsPerEngine": 100,
    "maxResults": 100,
    "onlyNew": false,
    "outputMode": "merged",
    "requestsPerSecond": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mmdincer/autocomplete-keyword-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 = {
    "keywords": ["coffee grinder"],
    "engines": [
        "google",
        "youtube",
        "bing",
    ],
    "country": "us",
    "language": "en",
    "expandAlphabet": True,
    "expandDigits": False,
    "expandQuestions": False,
    "expandModifiers": False,
    "maxSuggestionsPerEngine": 100,
    "maxResults": 100,
    "onlyNew": False,
    "outputMode": "merged",
    "requestsPerSecond": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("mmdincer/autocomplete-keyword-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 '{
  "keywords": [
    "coffee grinder"
  ],
  "engines": [
    "google",
    "youtube",
    "bing"
  ],
  "country": "us",
  "language": "en",
  "expandAlphabet": true,
  "expandDigits": false,
  "expandQuestions": false,
  "expandModifiers": false,
  "maxSuggestionsPerEngine": 100,
  "maxResults": 100,
  "onlyNew": false,
  "outputMode": "merged",
  "requestsPerSecond": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call mmdincer/autocomplete-keyword-scraper --silent --output-dataset

```

## MCP server setup

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