# Google Autocomplete Scraper (`graylark/google-autocomplete-scraper`) Actor

Keyword ideas from Google autocomplete: expand seeds with a-z, 0-9 and question words, for web or YouTube. $0.30 per 1,000 suggestions, no usage fees.

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

## Pricing

from $0.30 / 1,000 keyword suggestions

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/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 ideas from Google's search suggestions. Give it one or more seed keywords and it returns what Google suggests for each one. You can also expand each seed with the letters a to z, the digits 0 to 9, and question words such as how, what and best. The result is one table row per unique suggestion, with the query that produced it.

Google's suggestions are the lines that appear under the search box while you type. They show phrases people actually search for, so they are a common starting point for keyword research, content ideas and long-tail phrases. Suggestions do not include search volume.

### What it does

- Takes seed keywords, one per line.
- Asks Google for suggestions for each seed. Optionally it also asks for the seed followed by each letter and digit, and for the seed inside question and modifier patterns.
- Removes repeats (ignoring case) and removes any suggestion that is identical to the seed.
- Returns one row per unique suggestion, with the seed, the query that returned it and its position in Google's list.
- Works with Google web search or YouTube search suggestions.

### Input

Example input:

```json
{
  "keywords": ["coffee maker"],
  "country": "US",
  "language": "en",
  "expand": "alphabet",
  "source": "web",
  "maxConcurrency": 5
}
```

| Field | What it does | Default |
| --- | --- | --- |
| keywords | Seed keywords, one per line. Duplicates are removed. | coffee maker |
| country | Two-letter country code, such as US, GB or DE. Use GB, not UK. | US |
| language | Language code for the suggestions, such as en, de or fr-FR. | en |
| expand | none, alphabet, questions, or alphabet+questions (see below). | alphabet |
| source | web (Google search) or youtube (YouTube search). | web |
| maxConcurrency | How many IPs work in parallel, 1 to 10. | 5 |
| proxyConfiguration | Apify Proxy settings. | Apify Proxy |

Expansion options:

- none: the seed alone, 1 query.
- alphabet: the seed, then "seed a" to "seed z" and "seed 0" to "seed 9". 37 queries.
- questions: the seed, then "how seed", "what seed", "why seed", "where seed", "when seed", "who seed", "which seed", "can seed", "is seed", "best seed", "seed vs", "seed for" and "seed near me". 14 queries.
- alphabet+questions: all of the above. 50 queries.

### Output

Each row is one unique suggestion for one seed. Example row:

```json
{
  "keyword": "coffee maker with grinder",
  "seed": "coffee maker",
  "query": "coffee maker",
  "position": 2,
  "country": "US",
  "language": "en",
  "source": "web",
  "status": "ok",
  "scrapedAt": "2026-10-09T18:51:17Z"
}
```

The fields are:

- keyword: the suggestion.
- seed: the keyword you entered.
- query: the query Google answered, for example "how coffee maker" for the "how" pattern.
- position: where the suggestion sat in Google's list for that query, starting at 1.
- status: ok, noData or failed (see below).
- error: why a row is not ok.

The suggestions table view shows these fields as a table. The full dataset can be downloaded in JSON, CSV, Excel and other formats.

### Status values

| Status | Charged | When |
| --- | --- | --- |
| ok | Yes, one result | Google returned a suggestion that is not a repeat and not the seed. |
| noData | No | Every query for the seed worked, and Google returned nothing new. |
| failed | No | Google could not be reached for the seed's queries, or the run stopped before they ran. The error column says why. |

Rows with status noData or failed are free, so you never pay for an empty or failed seed.

### More from Graylark

[Google Trends Scraper & API](https://apify.com/graylark/google-trends-scraper): interest over time, interest by region, related queries and Trending Now for any keyword. Use it to check which of your keyword ideas are growing.

### FAQ

How many suggestions does one keyword give?
Google returns up to 10 suggestions per query. With none you get one list. With alphabet you get 37 lists, with questions 14, and with alphabet + questions 50. Repeats are removed, so the number of rows is lower than the total. Google sometimes returns fewer than 10 for a query, and some queries return almost nothing.

Why does the position start at 2?
Google often lists the keyword itself first. That exact keyword is never returned as a row, so position 1 is often missing from the results.

Can I get YouTube suggestions?
Yes. Set source to youtube. The rows then come from YouTube search suggestions.

Can I export the results to CSV or Excel?
Yes. Download the run's dataset from its storage in CSV or Excel format.

Is this an official Google API?
No. Google does not offer a public autocomplete API. This Actor reads the same suggestion service the search box uses, so Google can change or limit it at any time. This Actor is not affiliated with Google.

How long does a run take?
Each query takes a fraction of a second, but the Actor waits between requests so that Google does not block it. A single keyword with the questions option takes a few seconds. Large seed lists with alphabet + questions take longer, because each keyword sends 50 queries.

What happens when a run is cut short?
The Actor stops cleanly before the run timeout or the cost limit, saves what it found, and reports the seeds it could not finish as free failed rows.

### Pricing

$0.30 per 1,000 suggestions, the same on every Apify plan, plus $0.00005 per run. Platform usage is included, so there is no compute bill on top, and there is no per-run fee beyond that.

Example: one seed with alphabet expansion returns around 350 suggestions, which costs about $0.11.

Only rows with status ok are charged. noData and failed rows are never charged.

# Changelog

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

# Actor input Schema

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

Seed keywords, one per line, e.g. 'coffee maker'. Each seed gets its own list of Google suggestions. Duplicates (ignoring case) are removed.

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

Two-letter country code the suggestions are tailored to, like US, GB or DE (use GB, not UK).

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

Google interface language, e.g. en, de or fr-FR. It affects the suggestions returned, so use the language your keywords are typed in.

## `expand` (type: `string`):

None: suggestions for the seed alone (1 query). Alphabet: also seed + a to z and 0 to 9 (37 queries). Questions: also how, what, why, where, when, who, which, can, is, best, vs, for and near me (14 queries). Alphabet + questions: all of them (50 queries).

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

Where the suggestions come from: Google web search or YouTube search.

## `maxConcurrency` (type: `integer`):

How many IPs work in parallel (5 recommended). Rate-limited IPs are replaced automatically; higher finishes long lists faster.

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

Apify Proxy is used by default. Rate-limited IPs are replaced automatically; queries that keep failing get a last retry through residential IPs if your account has them.

## Actor input object example

```json
{
  "keywords": [
    "coffee maker"
  ],
  "country": "US",
  "language": "en",
  "expand": "alphabet",
  "source": "web",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per unique suggestion per seed keyword, plus one free row for any seed that failed or returned nothing. Check `status`: only `ok` items are charged.

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

Table view: suggestion, seed keyword, the query that returned it, position, country, source and status.

# 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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("graylark/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"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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