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

Collect public Google autocomplete suggestions by seed query, language and country with rank and collection metadata.

- **URL**: https://apify.com/benthepythondev/google-keyword-suggestions-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (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

from $2.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Data

Collect the public keyword ideas Google shows while a user types a search. Give
the Actor one or more seed queries and it returns ranked autocomplete
suggestions with the seed, language, country context, rank, source, and
collection time. The output is ready for keyword research, content planning,
search-intent discovery, marketplace taxonomy work, and repeatable SEO research.

The Actor uses Google's public suggestion response rather than opening a full
browser or scraping a search-results page. That keeps runs fast, predictable,
and inexpensive. No Google account, cookie export, or external API key is
required. Results are written to the default Apify dataset and can be exported
as JSON, CSV, Excel, XML, or RSS, fetched through the API, or sent into an
automation workflow.

### What this Actor returns

Each dataset item is one autocomplete suggestion. The result preserves the seed
query that produced it, so several seeds can be processed in one run without
losing provenance.

Typical fields include:

- `seed_query`: the word or phrase submitted to the suggestion service;
- `suggestion`: one public autocomplete phrase returned for that seed;
- `rank`: the suggestion's order in the response, starting at one;
- `language`: the Google interface-language context used for the request;
- `country`: the country context used for the request;
- `source`: `Google Autocomplete` for clear provenance;
- `scraped_at`: the UTC collection timestamp.

The dataset schema displays the most useful fields as a table in Apify Console,
while the complete records remain available in every supported export format.

### Common use cases

#### Long-tail keyword discovery

Start with a broad commercial or informational phrase and collect the longer
queries people may type around it. This is useful when creating a first topic
map or expanding an existing keyword list.

#### Content briefs and editorial planning

Use suggestion phrases as research inputs for article outlines, FAQ sections,
video topics, documentation pages, or support-center content. Autocomplete is a
discovery signal, not a complete content strategy, so combine it with business
relevance and firsthand subject knowledge.

#### Product and marketplace taxonomy

Teams can compare the language used around product categories, services,
locations, or problems. The seed-to-suggestion relationship makes it easy to
group phrases into navigation labels, filters, or internal search synonyms.

#### Localized research

Run the same seeds with different language and country settings to observe how
public suggestions vary by market. Country and language parameters influence
the request context but do not guarantee that every returned phrase is unique
to that location.

#### Scheduled change monitoring

Save a task with a stable list of seeds and run it weekly or monthly. Compare
datasets by `seed_query`, `suggestion`, and `rank` to identify newly appearing or
disappearing phrases.

### Input

The default input is intentionally small so a first run finishes quickly and
produces a useful dataset.

```json
{
  "queries": ["web scraping", "data extraction api"],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10
}
````

#### Input fields

- `queries`: a list of seed words or phrases. The Actor accepts up to 100
  non-empty seeds in one run.
- `language`: a short Google interface-language code such as `en`, `de`, `es`,
  or `fr`.
- `country`: a short country code such as `us`, `gb`, `de`, or `es`.
- `maxSuggestionsPerQuery`: the maximum number of ranked rows saved for each
  seed, from 1 to 50. Google's response may contain fewer rows.

Keep related seeds together when the resulting dataset will feed one project.
Split unrelated markets into separate tasks when you need cleaner scheduling,
cost tracking, or change comparisons.

### Example output

```json
{
  "seed_query": "web scraping",
  "suggestion": "web scraping in python",
  "rank": 4,
  "language": "en",
  "country": "us",
  "source": "Google Autocomplete",
  "scraped_at": "2026-07-10T12:00:00+00:00"
}
```

Suggestions are public phrases returned at collection time. A rank is only the
order in that response; it is not search volume, competition, CPC, trend growth,
or a guarantee of search demand. The Actor does not invent those metrics.

### Pricing and cost control

This Actor uses pay per event pricing:

- a small Actor-start event is charged once per run;
- the `result` event is charged once for each suggestion written to the default
  dataset.

The visible maximum-per-query input makes the upper result count predictable.
For example, 20 seeds with a limit of 10 can write at most 200 rows, although the
source may return fewer. Apify platform usage is shown separately by Apify.

### Run from the API

After creating an Apify API token, call the Actor through the standard Actor run
endpoint. Keep the token in an environment variable or secret manager rather
than embedding it in source code.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/benthepythondev~google-keyword-suggestions-scraper/runs?token=$APIFY_TOKEN" \
  -H "content-type: application/json" \
  -d '{"queries":["remote jobs","python developer"],"language":"en","country":"gb","maxSuggestionsPerQuery":10}'
```

The run response contains links to the default dataset. You can also create an
Apify task for a saved input, schedule that task, and use a webhook when the run
finishes.

### Automation ideas

- Append weekly suggestions to Google Sheets and compare rank changes.
- Send new phrases into Notion or an editorial backlog after deduplication.
- Group suggestions by seed before passing them to an internal research or RAG
  workflow.
- Combine phrase discovery with a separate news or content source to validate
  whether a topic has timely material.
- Use separate tasks for countries so costs and outputs remain attributable.

### Reliability and responsible use

The Actor retries transient request failures and fails the run explicitly when
no suggestions are returned. An empty successful dataset would hide source or
input problems, so it is treated as an error. Defaults are bounded for daily
auto-testing, and the Actor requests only the public suggestion response needed
for the supplied seeds.

Autocomplete phrases can include sensitive, inaccurate, or unexpected wording.
Review results before publication or automated decision-making. Do not treat a
suggestion as an endorsement by Google, proof of a person's intent, or a factual
claim. Respect applicable search-provider terms, privacy rules, and the laws in
your jurisdiction.

### Limitations

- The source may change suggestions between runs.
- Language and country settings influence context but do not simulate every
  user's exact location, history, or personalization.
- The Actor does not return search volume, CPC, keyword difficulty, SERP
  rankings, or trends.
- A phrase can appear for multiple seeds; that relationship is intentionally
  preserved rather than globally deduplicated.
- Google may return fewer suggestions than the configured maximum.

### Frequently asked questions

#### Does this need a Google API key?

No. It uses the public autocomplete response and does not require a Google
account or external API credential.

#### Can I use several seed queries?

Yes. Add them to `queries`; each row records its original `seed_query`.

#### Can I research German or Spanish phrases?

Yes. Set the language and country codes for the market you want to examine. The
output remains UTF-8 and can contain non-English text.

#### Does rank equal search volume?

No. Rank is only response order. Use a separate licensed keyword-data provider
when exact volume or advertising metrics are required.

#### Can I schedule it?

Yes. Save the input as an Apify task, attach a schedule, and consume the dataset
through exports, API calls, webhooks, or integrations.

#### What should I do if a run returns no data?

Check that the seeds are non-empty and use common language/country codes. The
Actor reports a failed run rather than silently succeeding with an empty
dataset. If valid inputs repeatedly fail, open an Actor issue with the run ID.

### Related Actors

- [Google News Scraper](https://apify.com/benthepythondev/google-news-scraper)
  for articles and source monitoring by query.
- [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor)
  for public business contact research from websites.
- [Webpage Text Extractor](https://apify.com/benthepythondev/webpage-text-extractor)
  for clean text from pages used in research pipelines.

If this Actor saves time in a real workflow, a short honest Store review helps
other users evaluate it. For a reproducible problem, open an issue with the run
ID, non-secret input, expected behavior, and the affected seed query.

**Keywords:** Google keyword suggestions scraper, Google autocomplete scraper,
keyword ideas API, long-tail keyword research, SEO keyword scraper, search query
suggestions, autocomplete data export, content research API, Apify SEO Actor.

# Actor input Schema

## `queries` (type: `array`):

Words or phrases for which Google autocomplete suggestions should be collected.

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

Google interface language, for example en, de, es or fr.

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

Two-letter country context, for example us, de, gb or es.

## `maxSuggestionsPerQuery` (type: `integer`):

Maximum ranked suggestions stored for each seed query.

## Actor input object example

```json
{
  "queries": [
    "web scraping"
  ],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "queries": [
        "web scraping"
    ],
    "language": "en",
    "country": "us",
    "maxSuggestionsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "queries": ["web scraping"],
    "language": "en",
    "country": "us",
    "maxSuggestionsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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 '{
  "queries": [
    "web scraping"
  ],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10
}' |
apify call benthepythondev/google-keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Keyword Suggestions Scraper - Autocomplete Data",
        "description": "Collect public Google autocomplete suggestions by seed query, language and country with rank and collection metadata.",
        "version": "1.0",
        "x-build-id": "RdFf9PNZlM3UjKthv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~google-keyword-suggestions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~google-keyword-suggestions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~google-keyword-suggestions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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",
                "properties": {
                    "queries": {
                        "title": "Seed queries",
                        "type": "array",
                        "description": "Words or phrases for which Google autocomplete suggestions should be collected.",
                        "default": [
                            "web scraping"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Google interface language, for example en, de, es or fr.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country context, for example us, de, gb or es.",
                        "default": "us"
                    },
                    "maxSuggestionsPerQuery": {
                        "title": "Maximum suggestions per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum ranked suggestions stored for each seed query.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```