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

Collect Google Autocomplete suggestions for seed keywords and return each suggestion with its query, position, relevance, type, country and language. Choose alphabet or question-word expansion to query related phrases, or use no expansion for suggestions on the seed alone.

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

## Pricing

from $0.60 / 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.
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

**Returns:** one row per Google Autocomplete suggestion with `suggestion`, `position`, `relevance`, `suggestType`, `query`, `seed`, `country` and `language`.
**Input:** `{"keywords": ["coffee"], "country": "us", "language": "en", "expansion": "alphabet", "maxItems": 100}`
**Best for:** keyword research for SEO and content plans, long-tail keyword lists for ads, and tracking what people search for in a market.

```json
{
    "seed": "running shoes",
    "query": "running shoes b",
    "expansion": "b",
    "suggestion": "running shoes brands",
    "position": 1,
    "relevance": 1250,
    "suggestType": "QUERY",
    "country": "us"
}
```

### What does Google Autocomplete Scraper do?

Google Autocomplete Scraper collects the search suggestions Google shows in the search box while someone types. You give it a list of seed keywords, a country and a language, and it returns every suggestion Google offers for each seed, with its position in the list, Google's relevance score and the suggestion type. It works as a simple Google Autocomplete API: no Google account, no login and no API key are needed.

One seed keyword gives up to 15 suggestions. To go deeper, turn on keyword expansion. Alphabet expansion asks Google for "seed a", "seed b" and so on through "seed z", and question expansion asks for "how seed", "what seed", "why seed" and the other common question words. One seed with full expansion sends 39 requests, which typically yields several hundred long-tail keyword ideas. You can paste hundreds of seeds at once, so the Actor is a bulk Google keyword suggestion tool.

People use it to build keyword lists for SEO and content calendars, to find long-tail phrases for search ads, to see which questions people ask about a product, and to compare what searchers type in different countries and languages. Every row says which seed and which exact query produced it, so you can sort, filter and group the data in a spreadsheet straight away.

### What data can you get from Google Autocomplete?

Each row in the dataset is one suggestion for one query.

| Field | Description | Example |
|---|---|---|
| `id` | Stable row ID: a hash of query, position, country and language | `947ccf987d45a4a8` |
| `seed` | The input keyword that produced this request | `running shoes` |
| `query` | The exact text sent to Google: the seed, `{seed} {letter}` or `{word} {seed}` | `running shoes b` |
| `expansion` | Letter (a-z) or question word used to build the query; `null` for the plain seed | `b` |
| `suggestion` | The suggestion text as Google returned it | `running shoes brands` |
| `position` | 1-based position of the suggestion in Google's list for this query | `1` |
| `relevance` | Google's relevance score for the suggestion; higher scores rank first | `1250` |
| `suggestType` | `QUERY` for a search phrase, `NAVIGATION` for a website URL | `QUERY` |
| `country` | Country code sent to Google (`gl`) | `us` |
| `language` | Language code sent to Google (`hl`) | `en` |
| `scrapedAt` | ISO 8601 time the suggestions were fetched | `2026-10-16T00:05:07.853Z` |
| `sourceUrl` | The Google Autocomplete request URL the row came from | `https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=running+shoes+b` |

A `NAVIGATION` suggestion is a website address that Google offers as a shortcut, for example `https://www.facebook.com/` when you type "faceb". Most rows are of type `QUERY`.

### How to use Google Autocomplete Scraper

1. Open Google Autocomplete Scraper in Apify Console and go to the Input tab.
2. Type your seed keywords into **Seed keywords**, one per line. Any language or script works, for example `kaffee` or `ラーメン`.
3. Set **Country** and **Language** for the market you care about, for example `de` and `de` for Germany in German.
4. Choose a **Keyword expansion** mode. Start with `none` to see the plain suggestions, then try `alphabet` or `questions` for more ideas.
5. Set **Maximum results** to the number of rows you want in total, across all seeds.
6. Click **Start**. A run with a few seeds finishes in seconds.
7. Open the Output tab to browse the rows, or export them as JSON, CSV, Excel, XML or HTML.

Some tips:

The `maxItems` limit is shared by all seeds. Seeds are processed in the order you give them, and each seed's expansion queries run before the next seed starts, so a small limit can be used up by the first seed. Raise `maxItems` if later seeds are missing from the output. For full alphabet and question expansion, allow about 400 rows per seed.

Suggestions depend on the country and language you set, and also a little on where the request comes from. Requests go direct first. If Google rate-limits them (HTTP 429 or 403), the run switches to the proxy you set in **Proxy configuration** and retries on fresh IPs. For the most local results, choose an Apify Proxy country that matches your `country` setting.

Duplicates are normal: the same suggestion can show up under several expansion queries of one seed. The default keeps every row, because the position under each query matters for SEO. Turn on **Remove duplicate suggestions** (`dedupe`) to keep only the first row for each suggestion text per seed.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `keywords` | array of strings | Yes | Seed keywords to get suggestions for. Blank lines and repeated seeds are ignored. |
| `country` | string | No | Two-letter country code sent as `gl`, e.g. `us`, `gb`, `de`, `jp`. Default `us`. |
| `language` | string | No | Language code sent as `hl`, e.g. `en`, `de`, `ja`, `pt-br`. Default `en`. |
| `expansion` | string | No | `none` (default), `alphabet`, `questions`, `digits`, `prepositions`, `both` or `all`. |
| `extraMarkets` | array of strings | No | Extra markets to query every seed in, as `country:language`, e.g. `de:de`. Each row's `country` and `language` fields say which market it came from. Default: none. |
| `dedupe` | boolean | No | Output each suggestion text only once per seed. Default `false`. |
| `maxItems` | integer | No | Maximum number of rows across all seeds, 1-10000, default 100. |
| `proxyConfiguration` | object | No | Proxy used after Google rate-limits direct requests. Default: Apify Proxy (datacenter). |

What each expansion mode sends for one seed:

| Mode | Queries per seed | Queries sent |
|---|---|---|
| `none` | 1 | the seed |
| `alphabet` | 27 | the seed, then `seed a` to `seed z` |
| `questions` | 13 | the seed, then `who`, `what`, `when`, `where`, `why`, `how`, `which`, `can`, `are`, `is`, `will` and `does` before the seed |
| `both` | 39 | the seed, the alphabet queries, then the question queries |
| `digits` | 11 | the seed, then `seed 0` to `seed 9` |
| `prepositions` | 13 | the seed, then `seed for`, `with`, `without`, `near`, `to`, `vs`, `versus`, `like`, `and`, `or`, `in` and `on` |
| `all` | 63 | the seed plus every query from the modes above |

The question words are English. They work best with English seeds; for other languages, alphabet expansion is usually the better choice.

Example input:

```json
{
    "keywords": ["running shoes", "trail shoes"],
    "country": "us",
    "language": "en",
    "expansion": "alphabet",
    "dedupe": false,
    "maxItems": 500,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

If a keyword has no suggestions at all, the run still succeeds: that keyword returns 0 rows and the log says so. Only input that can never work, such as an empty keyword list or an unknown expansion mode, stops the run with an error message.

### Output

These rows come from real runs. The first two are from the US English run for `running shoes` with alphabet expansion, the third from a German run for `kaffee`.

```json
[
    {
        "id": "484797f6ae88e483",
        "seed": "running shoes",
        "query": "running shoes",
        "expansion": null,
        "suggestion": "running shoes for women",
        "position": 1,
        "relevance": 651,
        "suggestType": "QUERY",
        "country": "us",
        "language": "en",
        "scrapedAt": "2026-10-16T00:05:06.686Z",
        "sourceUrl": "https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=running+shoes"
    },
    {
        "id": "947ccf987d45a4a8",
        "seed": "running shoes",
        "query": "running shoes b",
        "expansion": "b",
        "suggestion": "running shoes brands",
        "position": 1,
        "relevance": 1250,
        "suggestType": "QUERY",
        "country": "us",
        "language": "en",
        "scrapedAt": "2026-10-16T00:05:07.853Z",
        "sourceUrl": "https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=running+shoes+b"
    },
    {
        "id": "dd5e8ffbf2f00a18",
        "seed": "kaffee",
        "query": "kaffee",
        "expansion": null,
        "suggestion": "kaffeevollautomat",
        "position": 1,
        "relevance": 601,
        "suggestType": "QUERY",
        "country": "de",
        "language": "de",
        "scrapedAt": "2026-10-16T00:05:25.941Z",
        "sourceUrl": "https://suggestqueries.google.com/complete/search?client=chrome&hl=de&gl=de&ie=UTF-8&oe=UTF-8&q=kaffee"
    }
]
```

You can download the dataset as JSON, CSV, Excel, XML or HTML from the Output tab, or read it through the Apify API. The Overview view shows the seed, query, expansion, suggestion, position, relevance, type, country, language and source URL side by side.

### How much does it cost to scrape Google Autocomplete?

Google Autocomplete Scraper is charged per result, which here means per suggestion row. You pay only for the rows returned, and `maxItems` caps how many there can be, so it also caps the charge. Turning on `dedupe` removes repeated rows before they are saved, so you don't pay for them. See the Pricing tab for the current price.

If you set a maximum cost per run in the run options, the Actor stops cleanly when that limit is reached and tells you so in the status message, keeping every row it already saved.

### Use with AI agents (MCP)

Connect Google Autocomplete Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/google-autocomplete-scraper"
        }
    }
}
```

Example prompts:

1. "Get Google Autocomplete suggestions for 'standing desk' in the US with alphabet expansion, and group them by topic."
2. "Which questions do people in the UK ask Google about 'solar panels'? Use question expansion and list the top suggestions by relevance."
3. "Compare the Google suggestions for 'kaffee' in Germany and 'coffee' in the US and tell me what differs."

An agent only needs the `keywords` field; every other field has a sensible default. The `maxItems` field keeps a run small enough for an agent's context.

### Integrations and API

Run Google Autocomplete Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/google-autocomplete-scraper").call(run_input={
    "keywords": ["running shoes"],
    "country": "us",
    "language": "en",
    "expansion": "alphabet",
    "maxItems": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["query"], item["position"], item["suggestion"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/google-autocomplete-scraper').call({
    keywords: ['running shoes'],
    country: 'us',
    language: 'en',
    expansion: 'questions',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~google-autocomplete-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["coffee"], "country": "us", "language": "en", "expansion": "none", "maxItems": 20}'
```

The Integrations tab connects the Actor to Make, Zapier, n8n, Google Sheets, Slack and webhooks. A common setup is a weekly schedule that sends fresh suggestions for your main keywords to a Google Sheet, so you can see new phrases appear over time.

### FAQ

**Is this an official Google Autocomplete API?**
No. Google doesn't offer a public autocomplete API. The Actor reads the same suggestion data that Google's search box loads and turns it into clean rows.

**Why do I get fewer than 15 suggestions for a keyword?**
Google returns up to 15 suggestions per query, but rare or very specific keywords get fewer. A keyword nobody searches for may get none at all; that keyword returns 0 rows and the log mentions it.

**Why are the suggestions different from what I see in my browser?**
Your browser suggestions are personalised by your search history, signed-in account and exact location. The Actor's results are like those of an anonymous user in the country and language you set. The location of the requesting IP can still nudge some suggestions, so use a proxy country that matches your target country for the most local results.

**What does the relevance score mean?**
It is the score Google attaches to each suggestion. Higher scores rank higher in the list. Scores are useful for comparing suggestions within one query; they are not search volumes.

**How many rows does one seed give?**
Up to 15 with `none`, roughly 400 with `alphabet`, roughly 200 with `questions` and roughly 600 with `both`, before duplicates are removed. The exact number depends on the keyword.

**Can I use other languages and scripts?**
Yes. Set `language` and `country` and type the seeds in that language. Japanese, German, Arabic and other scripts are returned correctly.

**What happens when Google rate-limits the run?**
The Actor waits, retries, and switches to your proxy configuration after Google answers with HTTP 429 or 403. If a seed still can't be fetched, the run logs the error and goes on with the next seed.

**Can I run it on a schedule?**
Yes. Create a schedule in Apify Console and the Actor will collect fresh suggestions daily, weekly or at any interval you choose.

### Is it legal to scrape Google Autocomplete?

Google Autocomplete Scraper collects only publicly available search suggestions that anyone can see in the Google search box without logging in. The suggestions are short search phrases and contain no account data. You are responsible for how you use the data and for following the laws that apply to you. If in doubt, ask a lawyer; this section is not legal advice.

Google Autocomplete Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Google.

### Related Actors

| Actor | What it does |
|---|---|
| [Google Search SERP Scraper](https://apify.com/axiomworks/google-search-results-scraper) | Collects Google search result pages for your keywords |
| [Google Trends Scraper](https://apify.com/axiomworks/google-trends-scraper) | Collects Google Trends interest data for keywords |
| [Bing SERP Scraper](https://apify.com/axiomworks/bing-search-scraper) | Collects Bing search results for your keywords |
| [Semrush SEO Metrics Scraper](https://apify.com/axiomworks/semrush-domain-overview-scraper) | Collects SEO metrics for domains |

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

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

Seed keywords to get Google Autocomplete suggestions for, one per line, e.g. 'coffee' or 'running shoes'. Any language or script works. Each seed returns up to 15 suggestions per request (more with expansion). Blank lines and repeated seeds are ignored. A keyword Google has no suggestions for returns 0 rows and a log warning, not an error.

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

Two-letter country code sent to Google as gl, e.g. 'us', 'gb', 'de', 'jp'. Default 'us'. Use together with language to get suggestions as an anonymous user in that market sees them.

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

Language code sent to Google as hl, e.g. 'en', 'de', 'ja', 'pt-br'. Default 'en'. Pick the language your seeds are written in.

## `expansion` (type: `string`):

Extra queries per seed. 'none' (default): seed only. 'alphabet': + '{seed} a..z'. 'questions': + 'who/what/how/can/is... {seed}' (12 words). 'digits': + '{seed} 0..9'. 'prepositions': + '{seed} for/with/near/vs...' (12). 'both': alphabet + questions. 'all': everything. Seed is always queried first; each row's expansion field names the letter or word used.

## `dedupe` (type: `boolean`):

If true, output each suggestion text only once per seed (first occurrence wins), even when several expansion queries return it. Default false keeps every row, because the position under each query matters for SEO.

## `extraMarkets` (type: `array`):

Optional additional markets to query every seed in, each as 'country:language', e.g. 'de:de', 'br:pt-br'. Empty (default) uses only country and language. Each market multiplies requests; rows carry their country and language, and all markets share the maxItems budget.

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

Maximum number of suggestion rows to return across all seeds and expansions together, 1-10000, default 100. Seeds are processed in order, so a small limit may be used up by the first seed. The run stops as soon as this many rows are saved, and you are charged only for rows returned.

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

Proxy used when Google rate-limits or blocks requests, default Apify Proxy (datacenter). Requests go direct first; after a 429/403 the run switches to this proxy and retries on fresh IPs. Pick a proxy country matching 'country' for the most local results.

## Actor input object example

```json
{
  "keywords": [
    "coffee"
  ],
  "country": "us",
  "language": "en",
  "expansion": "none",
  "dedupe": false,
  "extraMarkets": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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"
    ],
    "country": "us",
    "language": "en",
    "expansion": "none",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/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"],
    "country": "us",
    "language": "en",
    "expansion": "none",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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