# Google Autocomplete Scraper — Keyword Suggestions, 4 Engines (`fabrikit/google-autocomplete-scraper`) Actor

Keyword suggestions from Google Autocomplete plus YouTube, Amazon and Bing for any seed: expand with a–z, 0–9, questions, prepositions or your own modifiers, drill down level by level, get relevance, type and search URL per row. Any language or country, no API key.

- **URL**: https://apify.com/fabrikit/google-autocomplete-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** SEO tools, E-commerce, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 keyword 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

## Google Autocomplete Scraper — keyword suggestions from Google, YouTube, Amazon and Bing

Google Autocomplete Scraper extracts keyword suggestions from google.com's autocomplete — and, in the same run, from YouTube, Amazon and Bing — for any seed keyword, in any language and country. It sends the queries the search boxes send, parses the JSON they answer with, and saves one clean row per suggestion: engine, seed keyword, query variant, suggestion text, position, Google's relevance score and type, and a ready-to-open search URL. No API key, no login, no browser.

Type `espresso machine` and Google answers with "espresso machine with grinder", "espresso machine near me", "espresso machine repair near me"… That is what people are actually typing. Turn on the **a–z expansion** and the Actor asks for `espresso machine a` … `espresso machine z`; add **questions** (`how espresso machine`, `why …`), **prepositions** (`espresso machine for`, `… without`), **comparisons** (`… vs`, `… alternative`) or your own modifiers, and a single seed grows into a few hundred long-tail keywords. **Drill-down** sends every suggestion back as a new seed for one, two or three more levels.

### What you get

| Field | Description |
|---|---|
| `engine` | `google`, `youtube`, `amazon` or `bing` |
| `keyword` | The seed keyword you entered |
| `query` | The exact string sent to the engine (seed, or seed + modifier) |
| `modifier`, `expansion` | Which modifier produced the query (`a`, `how`, `vs`, your custom word) and which set it belongs to (`none`, `alphabet`, `numbers`, `questions`, `prepositions`, `comparisons`, `custom`, `drill-down`) |
| `level` | 0 for your queries, 1–3 for drill-down levels |
| `suggestion` | The suggestion text |
| `position` | 1-based rank in the engine's answer |
| `relevance` | Google's relevance score (higher = shown first); `null` on the other engines |
| `suggestionType` | Google: `QUERY` or `NAVIGATION` (a site, e.g. `https://www.youtube.com/`); Amazon: `KEYWORD` |
| `subtypes` | Google/YouTube numeric subtype codes as returned (e.g. `[512, 433]`), `null` elsewhere |
| `navigationTitle` | Site name of a Google `NAVIGATION` row |
| `wordCount` | Words in the suggestion |
| `market`, `language`, `country`, `department` | Locale used (`en-US`, `amazon.com.mx`…) and the Amazon department alias |
| `searchUrl` | Search page for the suggestion on that engine |
| `scrapedAt` | ISO timestamp |

A `SUMMARY` record in the key-value store lists, per engine, how many queries were answered, how many suggestions were listed, saved, dropped as exact matches or skipped as duplicates, plus the proxy rung and browser header profile used.

### Use cases

- **Long-tail keyword research**: seed + a–z + questions on Google gives the phrases people complete, not the ones a tool guesses.
- **Content and FAQ planning**: the `questions` expansion returns "how", "why", "can" phrasings for articles, People-Also-Ask sections and chatbot intents.
- **YouTube titles and tags**: YouTube's own suggestions for a topic, by country.
- **Amazon listings and PPC**: what shoppers type in the search box of twelve marketplaces, optionally inside one department (`electronics`, `stripbooks`…).
- **Brand and reputation monitoring**: watch which completions appear next to a brand (`brand vs`, `brand alternative`, `is brand …`).
- **Datasets for AI**: thousands of real query completions per topic for classifiers, intent models or RAG evaluation.

### How to use

1. Enter one or more **seed keywords**.
2. Pick the **engines** (default Google).
3. Optionally choose **expansions**, add **custom modifiers** (a `*` marks where the seed goes: `mejor * 2026`), set **drill-down levels**, the **language/country** and, for Amazon, the **marketplace** and **department**.
4. Set **max suggestions**. The run stops exactly there.

```json
{
  "keywords": ["espresso machine", "milk frother"],
  "engines": ["google", "youtube", "amazon"],
  "expansions": ["alphabet", "questions"],
  "customModifiers": ["best * 2026", "under 500"],
  "language": "en",
  "country": "US",
  "amazonMarketplace": "com",
  "amazonDepartment": "aps",
  "maxItems": 1000
}
```

Example row:

```json
{
  "engine": "google",
  "keyword": "espresso machine",
  "query": "espresso machine w",
  "modifier": "w",
  "expansion": "alphabet",
  "level": 0,
  "suggestion": "espresso machine with grinder",
  "position": 1,
  "relevance": 601,
  "suggestionType": "QUERY",
  "subtypes": [512, 433],
  "navigationTitle": null,
  "wordCount": 4,
  "market": "en-US",
  "language": "en",
  "country": "US",
  "department": null,
  "searchUrl": "https://www.google.com/search?q=espresso%20machine%20with%20grinder&hl=en&gl=us",
  "scrapedAt": "2026-10-20T03:12:44.118Z"
}
```

#### How many suggestions to expect

Per query, Google returns up to 15 suggestions (with relevance and type), YouTube about 14, Amazon 10 and Bing up to about 23. With **Unique suggestions only** (default) each suggestion is saved once per engine, so a seed with the a–z expansion typically yields 150–300 unique Google keywords; the engine's echo of the query itself is dropped unless you turn on **Keep exact matches**. **Max suggestions per keyword and engine** keeps big seed lists balanced.

### Pricing

Pay per result: one `keyword-suggestion` event per suggestion saved, nothing else. See the Pricing tab for current prices; paid Apify plans get lower rates. Your plan's monthly limit and the run's **max charge** are both respected.

### Compared with alternatives

- **Google Ads Keyword Planner / paid SEO suites** give search volumes and CPC, which autocomplete does not expose; this Actor gives you the *actual completions* Google, YouTube, Amazon and Bing show, in bulk and per country. Use both: generate here, size there.
- **Single-engine autocomplete actors** cover Google or YouTube or Amazon; here one input and one dataset cover the four, with the same expansion and drill-down logic and Google's relevance score kept.
- **Typing by hand** shows 10 suggestions at a time and never the a–z or question variants.

For the next steps of a keyword workflow, [YouTube Search Scraper](https://apify.com/fabrikit/youtube-search-scraper) ranks the videos competing for a keyword and [Google Trends Scraper](https://apify.com/fabrikit/google-trends-scraper) shows its interest over time.

### Integrations

Run it from the Apify Console, on a **schedule**, or through the **API** (Node.js, Python, cURL) and export the dataset as JSON, CSV, Excel or XML. Connect it to **n8n**, **Make**, **Zapier**, Google Sheets or a webhook with the Apify integrations, and expose it to AI agents and LLM tools through Apify's **MCP server**.

### FAQ

**Is it legal?** The Actor reads the public suggestion endpoints the search boxes use, without logging in; suggestions are aggregated query text, not personal data. You are responsible for how you use the output and for complying with the terms of each engine.

**Do I need a proxy?** Apify datacenter proxy is on by default and should be enough. If an engine answers with a block (HTTP 403/429 or a captcha page) the Actor rotates browser header profiles and, after two blocks in a row, switches itself to RESIDENTIAL proxy in the chosen country for the rest of the run. Local or custom-proxy runs work too.

**Are there limits?** Each query returns at most 10–23 suggestions, which is why the expansions exist. Google and YouTube stop suggesting for very long or nonsense queries; the summary tells you how many queries came back empty. The run is capped by `maxItems` and your max charge.

**Does it give search volumes?** No — autocomplete engines do not publish them. Google's `relevance` is the only ranking signal available and it is kept.

**Which languages?** Any `language` code accepted by Google/YouTube/Bing (`es`, `pt-BR`, `de`, `ja`…) and any two-letter country. The built-in question/preposition words are English; use **Custom modifiers** for other languages (`cómo *`, `* barata`).

**Why fewer rows than queries × 15?** Unique suggestions only is on: the same keyword returned by `seed a` and `seed b` is saved once. Turn it off to keep one row per query variant.

### Changelog

- **0.1 (October 2026)** — Google (relevance, type, subtypes), YouTube, Amazon (12 marketplaces, department alias), Bing; a–z, 0–9, questions, prepositions, comparisons, custom modifiers with `*`; drill-down up to 3 levels; unique/exact-match filters; per-keyword cap; proxy and header-profile ladder; SUMMARY record.

***

### En español

**Google Autocomplete Scraper** extrae las sugerencias de autocompletado de Google, YouTube, Amazon y Bing para cualquier palabra clave semilla, en cualquier idioma y país, sin API key. Cada fila trae el motor, la semilla, la consulta enviada, la sugerencia, su posición, la relevancia y el tipo (Google) y la URL de búsqueda. Las expansiones a–z, 0–9, preguntas, preposiciones y comparaciones multiplican las consultas (`cafetera espresso a` … `z`); con **modificadores propios** puedes usar palabras en español (`mejor * 2026`, `* barata`, `cómo *`) y con los **niveles de profundización** cada sugerencia vuelve a consultarse como nueva semilla. Amazon admite doce tiendas (amazon.com, .es, .com.mx, .com.br, .de, .co.uk…) y un departamento. Consulta la pestaña Pricing para ver los precios vigentes; los planes de pago de Apify tienen tarifas más bajas. El proxy de datacenter de Apify basta y, si un motor bloquea, el Actor pasa solo a proxy residencial.

# Actor input Schema

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

One seed per entry, exactly as a user would start typing it, e.g. "espresso machine", "cafetera espresso", "how to invest". Each seed is sent to every selected engine.

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

Where to pull suggestions from. Google returns up to 15 per query with relevance and type, YouTube about 14, Amazon 10 (per marketplace and department), Bing up to about 23.

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

Extra queries built from each seed to surface many more suggestions: a–z ("seed a" … "seed z", 26 queries), 0–9 (10), question words in front ("how seed", "what seed"… 14), prepositions after ("seed for", "seed with"… 12) and comparisons ("seed vs", "seed or"… 6). Modifier words are English; use Custom modifiers for other languages.

## `customModifiers` (type: `array`):

Your own words to combine with each seed, one per entry. A word is appended ("espresso machine barata"); write \* where the seed should go to control the position ("mejor \* 2026", "cómo \*").

## `recursionDepth` (type: `integer`):

0 = only the suggestions for your queries. 1 = also send every suggestion found back as a new query, 2–3 = repeat on the new results. Each level multiplies the number of requests; maxItems always caps the run.

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

Interface language code for Google, YouTube and Bing suggestions: en, es, de, fr, pt-BR… (Amazon follows the marketplace).

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

Two-letter country code that localises Google, YouTube and Bing suggestions (US, GB, DE, MX, BR, IN…) and sets the country of the residential fallback proxy.

## `amazonMarketplace` (type: `string`):

Amazon storefront whose search box suggestions you want (only used when Amazon is selected).

## `amazonDepartment` (type: `string`):

Amazon search alias: aps = all departments (default). Others as in Amazon's own URLs (the i= parameter), e.g. electronics, stripbooks, fashion, beauty, toys-and-games, garden, sporting, grocery, pets, automotive, videogames, computers.

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

Stop after this many suggestions across all keywords and engines. You pay only for the rows that are saved.

## `maxItemsPerKeyword` (type: `integer`):

Cap for each seed keyword on each engine (0 = no cap). Handy with many seeds and expansions.

## `uniqueSuggestions` (type: `boolean`):

On: a suggestion is saved once per engine even if several query variants return it (a clean keyword list). Off: one row per query variant that returned it.

## `keepExactMatches` (type: `boolean`):

Engines often echo the query itself as the first suggestion. Off (default) drops those rows; on keeps them.

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

Apify datacenter proxy is enough in normal runs. If an engine answers with a block (HTTP 403/429 or a captcha page) the Actor rotates browser header profiles and, after two blocks in a row, switches to RESIDENTIAL proxy in the chosen country for the rest of the run.

## Actor input object example

```json
{
  "keywords": [
    "espresso machine"
  ],
  "engines": [
    "google"
  ],
  "expansions": [],
  "recursionDepth": 0,
  "language": "en",
  "country": "US",
  "amazonMarketplace": "com",
  "amazonDepartment": "aps",
  "maxItems": 50,
  "maxItemsPerKeyword": 0,
  "uniqueSuggestions": true,
  "keepExactMatches": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every suggestion saved during the run with its engine, seed keyword, query variant, position, relevance/type (Google) and search URL

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

Per-engine counts (queries answered, suggestions listed/saved, exact matches dropped, duplicates), per-keyword totals, proxy and header profile used, errors

# 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": [
        "espresso machine"
    ],
    "engines": [
        "google"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/google-autocomplete-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": ["espresso machine"],
    "engines": ["google"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/google-autocomplete-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": [
    "espresso machine"
  ],
  "engines": [
    "google"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/google-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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