# Google Autocomplete Keyword Scraper : a-z, questions, CSV/JSON (`tallyrake/google-autocomplete-scraper`) Actor

Google Autocomplete suggestions as flat rows: seed keyword, expansion (a-z, questions, prepositions, comparisons), rank, language and country, with a stable id per row. $0.25 per 1,000 rows.

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

## Pricing

$0.25 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Autocomplete Keyword Scraper: a-z, questions, CSV/JSON

Google Autocomplete as CSV/JSON rows. Give it seed keywords; it requests suggestions for the seed, seed + a to z, question words, and prepositions (comparisons and numbers only if you enable those expansions), for the language and country you set. One flat row per unique suggestion per seed, each with a stable `id`. $0.25 per 1,000 dataset rows.

### What you get

| Field | Example |
|---|---|
| `id` | `ce51808c1c50ed7e` (stable per seed, country, language, query and suggestion) |
| `keyword` | `coffee grinder` (your seed) |
| `query` | `coffee grinder b` (the exact string sent to Autocomplete) |
| `suggestion` | `coffee grinder burr` |
| `rank` | `1` (position in Google's list for that query) |
| `expansion` | `direct`, `alphabet`, `question`, `preposition`, `comparison`, `number`, `depth` |
| `modifier` | `b`, `how`, `for`, `vs` |
| `depth` | `1` or `2` |
| `relevance` | `1250` (chrome source only, otherwise null) |
| `suggestType` | `QUERY` (chrome source only, otherwise null) |
| `subtypes` | `[512, 433]` (Google's suggestion subtype codes, when present) |
| `language`, `country` | `en`, `us` |
| `fetchedAt` | ISO timestamp |

Rows are deduplicated per seed (case-insensitive), so a suggestion that appears under several modifiers is counted once, under the first query that produced it.

### Where this sits on the shelf

Apify Store search for "google autocomplete", top 10 results on 2026-09-11, read from the Store API. Price is the pay-per-event charge per dataset item, converted to per 1,000 rows; users, runs and the failed-or-timed-out share are the Store's 30-day public stats for each listing.

| Listing | Users (30d) | Runs (30d) | Failed or timed out | Price per 1,000 rows |
|---|---|---|---|---|
| automation-lab/google-autocomplete-scraper | 81 | 864 | 0% | free |
| memo23/google-suggest-scraper | 34 | 105 | 1% | $0.50 |
| aitorsm/keyword-fanout | 17 | 68 | 0% | $0.05 |
| scrape.badger/google-autocomplete-scraper | 14 | 88 | 10% | $0.01 |
| johnvc/google-autocomplete-api | 7 | 29 | 0% | $0.01 |
| lofomachines/google-search-autocomplete-cheaper-fast | 2 | 256 | 0% | free |
| vonsensey/google-autocomplete-keyword-scraper | 1 | 166 | 0% | free |
| hichemdev/google-autocomplete-keywords | 1 | 219 | 0% | $2.50 |
| devilscrapes/google-autocomplete-bulk | 0 | 29 | 0% | $200.00 |
| tallyrake/google-autocomplete-scraper (this actor) | 1 | 1 | 0 of 1 | $0.25 |

### Recipes

**Content brief for one topic.** Seeds: your topic. Expansions: questions, prepositions. Depth 1. Output: the questions and phrasings Google suggests for the topic, in Google's order.

**Keyword list for a niche.** Seeds: 10 to 50 head terms. Expansions: alphabet. Depth 2. Google returns at most 10 suggestions per query on the firefox source (8 on chrome), and `maxQueriesPerKeyword` (default 300) caps the requests per seed, so the most a seed can bill is 300 queries x 10 rows = 3,000 rows = $0.75; at the measured yield of about 4.2 rows per query a full 300-query seed is about 1,260 rows, about $0.32. For 10 to 50 seeds there is no measured run yet; start at concurrency 3 without a proxy, as in the measured run, and turn on Apify Proxy only if the log shows 429 or 403 responses.

**Localized suggestions.** Same seeds, `language` and `country` set per run (`de`/`de`, `es`/`mx`, `ja`/`jp`). Rows carry both codes so runs can be merged.

**Brand and competitor monitoring.** Seeds: brand names. Expansions: comparisons, questions. Schedule daily. Diff the `suggestion` column between runs.

### Input

Paste seeds one per line. The default expansions send 52 queries per seed (1 seed + 26 letters + 14 question words + 11 prepositions = 52). Comparisons and numbers are not in that 52; they are extra expansions. One seed is not one billable unit: at the measured yield of about 4.2 unique rows per query, the 52 default queries produce about 220 rows per seed, about $0.055 per seed at $0.25 per 1,000 rows. `maxQueriesPerKeyword` caps the requests per seed. The `chrome` source returns relevance scores and suggestion types; `firefox` returns up to 10 plain suggestions per query.

### Reliability and cost

Measured on 2026-09-11 on Apify: 2 seeds (`coffee grinder`, `pytrends 429`), firefox source, expansions alphabet + questions + prepositions (52 queries per seed), concurrency 3, no proxy, `en`/`us`: 104 queries produced 441 dataset rows (about 4.2 per query), 0 rate-limited responses, 13 seconds. That run bills $0.11 in results (441 rows at $0.25 per 1,000) plus $0.0025 of platform compute. Every request is paced with a jittered delay (`pacingMs`, default 200 ms). If Google answers 429 or 403, the run rotates its session and retries; that path was not exercised in the measured run.

Pay per event: $0.25 per 1,000 dataset rows, plus Apify platform usage for the run (compute was $0.0025 for the run above; the results charge, $0.11, is the larger part). Empty queries produce no rows and no results charge.

### Cost limit

If a run reaches the "Maximum total charge per run" you set, it stops in process rather than being aborted by the platform: the run ends with status SUCCEEDED, and the run status message on the run detail says how many rows were written and how many were found but not written and not billed. Re-running the same input writes and bills the same prefix again, so raise the cap before re-running if you want the rest.

### Limits

Autocomplete is Google's suggestion list for the language and country you set, at the time of the run. It carries no search volume; pair it with a Google Trends actor for demand. Google returns at most 10 suggestions per query (8 for the chrome source). Export CSV for Excel and Google Sheets. Export JSON for pipelines.

# Actor input Schema

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

One seed per line. Each seed is expanded (see Expansions) and every expanded query is sent to Google Autocomplete.

## `expansions` (type: `array`):

How to fan each seed out. alphabet: seed + a..z (26 queries). questions: who/what/why/how/when/where/which/is/are/can/does/do/will/should + seed (14). prepositions: seed + for/with/without/to/near/in/on/from/like/after/before (11). comparisons: seed + vs/or/versus/and (4). numbers: seed + 1..5/10/2026 (7). The plain seed is always queried.

## `depth` (type: `integer`):

1 = expand the seeds only. 2 = also send every first-level suggestion back to Autocomplete (capped by Max queries per keyword).

## `maxQueriesPerKeyword` (type: `integer`):

Cap on the number of Autocomplete requests made per seed, across expansions and depth.

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

Google interface language code, e.g. en, de, es, fr, pt, ja.

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

Two-letter country code that localises the suggestions, e.g. us, gb, de, in, br.

## `client` (type: `string`):

firefox returns up to 10 suggestions per query. chrome returns up to 8 with a relevance score and suggestion type per row.

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

Keep the first occurrence of each suggestion per seed keyword (case-insensitive).

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

Off by default; the Autocomplete endpoint tolerates a few hundred paced requests from one address. Turn Apify Proxy on for large keyword lists or if you see rate limiting in the log.

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

Parallel Autocomplete requests. 3 is safe without a proxy; up to 10 with Apify Proxy.

## `pacingMs` (type: `integer`):

Base jittered delay between requests per worker; 0 disables pacing.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "expansions": [
    "alphabet",
    "questions",
    "prepositions"
  ],
  "depth": 1,
  "maxQueriesPerKeyword": 300,
  "language": "en",
  "country": "us",
  "client": "firefox",
  "dedupe": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 3,
  "pacingMs": 200
}
```

# Actor output Schema

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

All suggestion rows (one per suggestion per seed).

## `csv` (type: `string`):

The same rows as CSV.

# 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 grinder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tallyrake/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 grinder"] }

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

```

## MCP server setup

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