# Google Autocomplete Scraper - Alphabet Soup Keywords (`kamerozkan/google-autocomplete-scraper`) Actor

Google Autocomplete and Google Suggest keywords in bulk: alphabet soup expansion (a-z, 0-9, questions, prepositions) of your seed keywords for any country and language. One row per suggestion with seed, modifier and position. No login, no API key.

- **URL**: https://apify.com/kamerozkan/google-autocomplete-scraper.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.64 / 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.
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 - Alphabet Soup Keywords

Get hundreds of long-tail keyword ideas from Google Autocomplete (Google Suggest) for any seed keyword, country and language: alphabet soup a-z, 0-9, question words, prepositions and your own modifiers, deduplicated, one row per suggestion.

### What does Google Autocomplete Scraper do?

It types your seed keyword into Google's search box the way a person would, adds every letter, number or question word you choose, and collects every suggestion Google shows (up to 15 per query). One seed keyword with alphabet soup and question words returned 549 unique suggestions in 40 seconds in our test run. Requests leave from the country you pick, so a UK run shows what people in the UK search for.

No login, no Google account, no API key and no proxy setup on your side: proxies are included in the price.

### Who is it for?

- **SEO agencies and content marketers**: build keyword lists and blog topic clusters from real searches, including the questions people ask.
- **PPC teams**: find long-tail and negative keywords per country before you build a Google Ads campaign.
- **E-commerce and Amazon sellers**: see which features, brands and comparisons buyers type after a product name.
- **Product and market researchers**: compare what people search for in the US, UK, Germany or any other country.

### What data can you get?

| Field | Example |
|---|---|
| `suggestion` | coffee maker with grinder |
| `keyword` | coffee maker (your seed keyword) |
| `modifier` | `""` for the plain keyword, `a` to `z`, `0` to `9`, `how ...`, `vs`, or your custom modifier |
| `query` | coffee maker a (exactly what was sent to Google) |
| `position` | 1 (place in Google's suggestion list, 1 to 15) |
| `relevance` | 601 (Google's own relevance score for the suggestion) |
| `suggestionType` | QUERY |
| `countryCode`, `languageCode` | us, en |
| `wordCount` | 4 |
| `isQuestion` | true when the suggestion starts with who, what, how, why, can, is and similar |
| `containsKeyword` | true when the suggestion contains your seed keyword |
| `scrapedAt` | 2026-10-14T16:16:07Z |

Every suggestion appears once per country, even when several modifiers or seed keywords return it, so you never pay twice for the same keyword.

### How much does it cost?

You pay only for unique suggestions: **$0.80 per 1,000 suggestions** on the Free plan, with lower prices on paid Apify plans. Proxies and platform usage are included.

Examples on the Free plan:

- 1 seed keyword with alphabet soup and question words, about 550 suggestions: about $0.44.
- 200 suggestions (the prefilled limit): $0.16.

Set **Max suggestions** or a maximum cost per run to cap spending.

### How to use it

1. Click **Try for free**.
2. Enter one or more seed keywords, for example `coffee maker`.
3. Pick the countries (`us`, `gb`, `de` ...) and the modifiers: alphabet soup and question words are on by default; numbers, prepositions and custom modifiers are optional.
4. Click **Start** and download the keywords as JSON, CSV, Excel or via API.

### Input example

```json
{
  "keywords": ["kaffeemaschine", "laufschuhe"],
  "countryCodes": ["de"],
  "expandAlphabet": true,
  "expandQuestions": false,
  "expandNumbers": true,
  "maxItems": 300
}
```

For German, French, Spanish, Turkish and other languages the alphabet soup also adds the local letters (for example ä, ö, ü). Custom modifiers can place the keyword anywhere with `{keyword}`, for example `best {keyword} for`.

### Output example

Real rows from our test runs on 2026-10-14 (UK, question words on):

```json
[
  {
    "suggestion": "why standing desk is better",
    "keyword": "standing desk",
    "modifier": "when ...",
    "query": "when standing desk",
    "position": 8,
    "relevance": 553,
    "suggestionType": "QUERY",
    "countryCode": "gb",
    "languageCode": "en",
    "wordCount": 5,
    "isQuestion": true,
    "containsKeyword": true
  },
  {
    "suggestion": "how long should you stand at a standing desk",
    "keyword": "standing desk",
    "modifier": "when ...",
    "query": "when standing desk",
    "position": 10,
    "relevance": 551,
    "suggestionType": "QUERY",
    "countryCode": "gb",
    "languageCode": "en",
    "wordCount": 9,
    "isQuestion": true,
    "containsKeyword": true
  }
]
```

Germany, plain keyword:

```json
{
  "suggestion": "kaffeemaschine mit mahlwerk",
  "keyword": "kaffeemaschine",
  "modifier": "",
  "query": "kaffeemaschine",
  "position": 1,
  "relevance": 601,
  "suggestionType": "QUERY",
  "countryCode": "de",
  "languageCode": "de",
  "wordCount": 3,
  "isQuestion": false,
  "containsKeyword": true
}
```

### Integrations and API

Run it from your code with the Apify API or the `apify-client` package, schedule it in Apify, or connect it to Make, n8n, Zapier, Google Sheets or a webhook.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("kamerozkan/google-autocomplete-scraper").call(run_input={
    "keywords": ["coffee maker"], "countryCodes": ["us"], "maxItems": 200})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["suggestion"])
```

### FAQ

**What is alphabet soup keyword research?** You type your keyword followed by every letter (`coffee maker a`, `coffee maker b`, ...) and write down what Google suggests. This Actor does it for all letters, digits and question words in one run and removes duplicates.

**Why do results differ by country?** Google suggests what people in that country search for, based on both the country setting and where the request comes from. Each country in `countryCodes` is queried from that country.

**Do I get search volume?** No. Google Autocomplete does not publish search volume. `position` and `relevance` show how strongly Google ranks a suggestion; use a volume tool on the final list if you need numbers.

**Some suggestions do not contain my keyword. Why?** Google sometimes suggests related searches. Filter on `containsKeyword` if you only want exact variations.

**Is it legal to collect this data?** It collects publicly available search suggestions only, no personal data. You are responsible for how you use it.

### Support and feedback

- Found a bug or missing a field? Open an issue on the **Issues** tab with your run link. We reply within 48 hours.
- Have an idea for a feature (for example YouTube or Amazon suggestions)? Issues are the fastest way to get it built.

# Actor input Schema

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

Seed keywords to expand, for example 'coffee maker' or 'crm software'. Each keyword is sent to Google Autocomplete on its own and with every modifier you enable below (up to 100 keywords).

## `countryCodes` (type: `array`):

Two-letter country codes such as us, gb, de, fr, es, br or in. Suggestions differ by country, so each country is a separate market and the requests leave from that country. Duplicates are removed per country.

## `languageCode` (type: `string`):

Interface language for Google, for example en, de or es. Leave empty to use the main language of each country (us: en, de: de, br: pt).

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

Add every letter after the keyword ('coffee maker a', 'coffee maker b', ...). For de, fr, es, tr and other languages the local letters (for example ä, ö, ü) are added too.

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

Put question words before the keyword ('how coffee maker', 'why coffee maker', 'can coffee maker', ...). Great for FAQ and blog topics.

## `expandNumbers` (type: `boolean`):

Add every digit after the keyword ('coffee maker 1', ...). Finds model numbers, years and sizes.

## `expandPrepositions` (type: `boolean`):

Add for, with, without, vs, near, to, like, and, or, in after the keyword ('coffee maker vs', 'coffee maker for').

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

Your own words to add after the keyword, such as 'best', 'price' or 'review'. Use {keyword} to place the keyword yourself, for example 'best {keyword} for'.

## `includeSeedKeyword` (type: `boolean`):

Also return a row when Google suggests exactly your seed keyword. Off by default, so you only pay for new keywords.

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

Stop after this many unique suggestions in total. You are charged per suggestion, so this also caps the cost of the run. One keyword with alphabet soup and questions gives about 300 to 450 suggestions.

## Actor input object example

```json
{
  "keywords": [
    "coffee maker"
  ],
  "countryCodes": [
    "us"
  ],
  "expandAlphabet": true,
  "expandQuestions": true,
  "expandNumbers": false,
  "expandPrepositions": false,
  "includeSeedKeyword": false,
  "maxItems": 200
}
```

# Actor output Schema

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

One row per result in the default dataset.

# 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"
    ],
    "countryCodes": [
        "us"
    ],
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/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": ["coffee maker"],
    "countryCodes": ["us"],
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("kamerozkan/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": [
    "coffee maker"
  ],
  "countryCodes": [
    "us"
  ],
  "maxItems": 200
}' |
apify call kamerozkan/google-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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