# Google Keyword Suggestions Scraper (Autocomplete) (`scrapemint/google-keyword-suggestions-scraper`) Actor

Expand any seed keyword into hundreds of real Google or YouTube autocomplete suggestions: a to z suffixes, question and preposition modifiers, deduped, one row per suggestion. No login, no API key. Pay per row.

- **URL**: https://apify.com/scrapemint/google-keyword-suggestions-scraper.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** SEO tools, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Keyword Suggestions Scraper (Autocomplete)

Turn one seed keyword into hundreds of real search queries people type. This Actor fans a seed out through Google (or YouTube) autocomplete with a to z suffixes, question prefixes and preposition suffixes, dedupes everything, and returns one clean row per unique suggestion. No login, no API key, no browser.

### What you get

One row per unique suggestion, with:

- `suggestion` (the query people actually type)
- `seedKeyword`, `modifier` (which expansion found it: `base`, `letter:a`, `question:how`, `preposition:vs`, ...)
- `position` (rank within its autocomplete response)
- `wordCount`, `source` (`google` or `youtube`), `language`, `country`, `scrapedAt`

A single seed with default settings typically yields 200 to 400 unique suggestions.

### Input

- `keywords` (seed keywords, each expanded separately)
- `source` (Google Search or YouTube Search suggestions)
- `language`, `country` (e.g. `en` / `us`, `de` / `de`)
- `expandLetters`, `expandDigits`, `expandQuestions`, `expandPrepositions`
- `maxRowsPerKeyword`, `maxRows`

### Example input

```json
{
  "keywords": ["project management software", "crm"],
  "language": "en",
  "country": "us"
}
````

YouTube content research:

```json
{
  "keywords": ["sourdough bread"],
  "source": "youtube",
  "expandQuestions": true
}
```

### Uses

- Keyword research: long tail queries that keyword tools miss or charge for
- Content planning: the `question:` rows are ready made article and FAQ topics
- YouTube video research with `source: youtube`
- Pairs with the [Google Trends Scraper](https://apify.com/scrapemint/google-trends-scraper): suggestions from this Actor in, interest timelines and rising queries from Trends out

### Pricing

Pay per row. The first 10 rows of every run are free so you can validate output before you scale up. A full default expansion of one seed costs about 20 to 40 cents.

### Notes

- Suggestions come from Google's public autocomplete endpoint, the same one the search box uses, so rows reflect what real users type right now in your chosen language and country.
- Requests are paced and the Actor stops early with results if the endpoint starts rate limiting, so a blocked run never spins compute.
- Autocomplete is a suggestion source, not a volume source; it does not include search volumes. Feed rows into Trends or your SEO tool for volumes.
- This Actor reads only public data and never logs in.

# Actor input Schema

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

One or more seed keywords to expand, e.g. "project management software". Each seed is fanned out through the enabled modifiers.

## `source` (type: `string`):

Where the autocomplete suggestions come from.

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

Autocomplete language code, e.g. en, es, fr, de, pt.

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

Two letter country code, e.g. us, gb, ca, au, in, de.

## `expandLetters` (type: `boolean`):

Query the seed followed by each letter ("seed a" ... "seed z"). The biggest source of long tail suggestions.

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

Query the seed followed by each digit. Useful for products, versions and years.

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

Query how/what/why/when/where/which/who/can/is/are/best in front of the seed. The rows content teams want.

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

Query the seed followed by for/with/without/vs/versus/near/like/to. Surfaces comparison and use case queries.

## `maxRowsPerKeyword` (type: `integer`):

Cap on unique suggestion rows per seed keyword.

## `maxRows` (type: `integer`):

Maximum suggestion rows across all seeds. First 10 rows per run are free.

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

Optional. The endpoint is tolerant and requests are paced, so proxy is off by default. Supply one only if you run very large expansions and see rate limit warnings.

## Actor input object example

```json
{
  "keywords": [
    "project management software"
  ],
  "source": "google",
  "language": "en",
  "country": "us",
  "expandLetters": true,
  "expandDigits": false,
  "expandQuestions": true,
  "expandPrepositions": true,
  "maxRowsPerKeyword": 400,
  "maxRows": 2000
}
```

# 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": [
        "project management software"
    ],
    "language": "en",
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/google-keyword-suggestions-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": ["project management software"],
    "language": "en",
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/google-keyword-suggestions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "project management software"
  ],
  "language": "en",
  "country": "us"
}' |
apify call scrapemint/google-keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/google-keyword-suggestions-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Keyword Suggestions Scraper (Autocomplete)",
        "description": "Expand any seed keyword into hundreds of real Google or YouTube autocomplete suggestions: a to z suffixes, question and preposition modifiers, deduped, one row per suggestion. No login, no API key. Pay per row.",
        "version": "0.1",
        "x-build-id": "UIEQFF8HHY33h06w7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~google-keyword-suggestions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-google-keyword-suggestions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemint~google-keyword-suggestions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-google-keyword-suggestions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemint~google-keyword-suggestions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-google-keyword-suggestions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "One or more seed keywords to expand, e.g. \"project management software\". Each seed is fanned out through the enabled modifiers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "source": {
                        "title": "Suggestion source",
                        "enum": [
                            "google",
                            "youtube"
                        ],
                        "type": "string",
                        "description": "Where the autocomplete suggestions come from.",
                        "default": "google"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Autocomplete language code, e.g. en, es, fr, de, pt.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two letter country code, e.g. us, gb, ca, au, in, de.",
                        "default": "us"
                    },
                    "expandLetters": {
                        "title": "Expand with a to z suffixes",
                        "type": "boolean",
                        "description": "Query the seed followed by each letter (\"seed a\" ... \"seed z\"). The biggest source of long tail suggestions.",
                        "default": true
                    },
                    "expandDigits": {
                        "title": "Expand with 0 to 9 suffixes",
                        "type": "boolean",
                        "description": "Query the seed followed by each digit. Useful for products, versions and years.",
                        "default": false
                    },
                    "expandQuestions": {
                        "title": "Expand with question prefixes",
                        "type": "boolean",
                        "description": "Query how/what/why/when/where/which/who/can/is/are/best in front of the seed. The rows content teams want.",
                        "default": true
                    },
                    "expandPrepositions": {
                        "title": "Expand with preposition suffixes",
                        "type": "boolean",
                        "description": "Query the seed followed by for/with/without/vs/versus/near/like/to. Surfaces comparison and use case queries.",
                        "default": true
                    },
                    "maxRowsPerKeyword": {
                        "title": "Max suggestions per seed",
                        "type": "integer",
                        "description": "Cap on unique suggestion rows per seed keyword.",
                        "default": 400
                    },
                    "maxRows": {
                        "title": "Max rows total",
                        "type": "integer",
                        "description": "Maximum suggestion rows across all seeds. First 10 rows per run are free.",
                        "default": 2000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The endpoint is tolerant and requests are paced, so proxy is off by default. Supply one only if you run very large expansions and see rate limit warnings."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
