# Google Autocomplete API — Bulk Keyword Scraper (`devilscrapes/google-autocomplete-bulk`) Actor

Bulk Google Autocomplete (Suggest) scraper and API — run many seeds × languages × countries per run with optional A–Z expansion for long-tail keyword research. Export suggestions to JSON or CSV. Public Suggest endpoint, no auth, no key. A keyword suggestion tool for SEO. Search suggestions data API.

- **URL**: https://apify.com/devilscrapes/google-autocomplete-bulk.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** SEO tools
- **Features:** Limited permissions
- **Stats:** 1,129 total users, 20 monthly users, 81.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.88 / 1,000 suggestion row emitteds

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

<img src=".actor/icon.svg" width="160" alt="Google Autocomplete Scraper" />

## Google Autocomplete Scraper — Bulk Suggest API

*We do the dirty work so your dataset stays clean.* 😈

**$1.00 / 1,000 suggestions** — Export real Google autocomplete suggestions for hundreds of seeds across many languages and countries in a single run. Optional A–Z alphabet expansion turns every seed into 26 long-tail variants. No SerpApi key. No Google account required.

Google's autocomplete dropdown is the canonical signal of what people are actually typing into the search box. Keyword-research SaaS tools like KeywordTool.io, AnswerThePublic, Ubersuggest, and SE Ranking all wrap the same public Suggest endpoint, mark it up 10–100×, and resell it. This Actor queries the endpoint directly, fans out across seeds × languages × countries, optionally expands each seed alphabetically, and emits one denormalised dataset row per (seed × suggestion × locale) tuple — ready for SEO, PPC, content-gap, or product-research workflows.

### 🎯 What this scrapes

For every (seed × language × country) combination you submit, this google autocomplete scraper queries Google's Suggest endpoint (`suggestqueries.google.com/complete/search`) and emits one row per returned suggestion. The default `client=chrome` mode returns up to 15 suggestions per call plus relevance scores and subtype tags; the lean `client=firefox` mode returns up to 10 suggestions without relevance scores. Each row carries the seed, the suggestion, its 0-indexed position, the locale used, and an `is_expansion` flag so alphabet-expanded long-tail suggestions are easy to filter or aggregate.

| Field | Type | Description |
|---|---|---|
| `seed` | string | The query string the suggestion was generated for |
| `suggestion` | string | One Google autocomplete suggestion |
| `position` | integer | 0-indexed position in the suggestion list |
| `relevance` | integer | null | `google:suggestrelevance` score (chrome client only) |
| `subtype` | string | First `google:suggesttype` tag (`QUERY`, `NAV`, …) or `UNKNOWN` |
| `language` | string | `hl` parameter used (ISO-639-1) |
| `country` | string | `gl` parameter used (ISO-3166-1 alpha-2) |
| `client` | string | `chrome` or `firefox` |
| `is_expansion` | boolean | True if the seed was produced by alphabet expansion |
| `parent_seed` | string | null | Original user seed when `is_expansion` is true |
| `scraped_at` | string | ISO 8601 UTC datetime |

### 🔥 Features

- **Bulk seeds** — submit up to 500 seed queries in a single run; the Actor fans out across every language × country combination you specify.
- **Multi-locale** — query the same seed across many languages (`hl`) and many countries (`gl`) in one run. The Suggest endpoint serves locale-specific results: "bestes auto" in `de`-`de` returns German automotive suggestions; "best laptop" in `en`-`us` returns US tech suggestions.
- **A–Z alphabet expansion** — toggle `enableAlphabetExpansion` to also query `<seed> a`, `<seed> b`, …, `<seed> z` for every seed. This is the canonical long-tail discovery technique: one seed × 26 letters reveals every common Google query that starts with your seed.
- **Two client variants** — `chrome` (default) returns up to 15 suggestions with relevance scores and subtype tags; `firefox` returns up to 10 suggestions in a leaner payload.
- **Denormalised output** — every row carries the seed, locale, and provenance fields so a flat CSV is self-contained for SQL / BI / spreadsheet workflows without joins.
- **We retry with exponential backoff** — 408 / 429 / 5xx responses trigger automatic retries (up to 5 attempts, honours `Retry-After`). You get results; we handle the turbulence.
- **Optional Apify Proxy routing** — switch on `useProxy` to send requests through an Apify Proxy datacenter pool; it is off by default.
- **Conservative concurrency** — 2 in-flight requests per run by default; the Actor backs off gracefully when the target rate-limits and surfaces partial results with a clear status message rather than returning an empty dataset.
- **Input validation** — locale codes are normalised to lowercase, length-validated, and rejected up-front if invalid before any network call.

### 💡 Use cases

- **Long-tail SEO keyword discovery** — enable alphabet expansion to enumerate every common Google query that starts with your seed; pipe into a search-volume tool to prioritise content briefs.
- **AnswerThePublic alternative** — get the same autocomplete suggestions direct from Google for a fraction of the cost. 1,000 suggestions = $1.20 here vs $89–199/mo for a SaaS dashboard that wraps the same endpoint.
- **PPC negative-keyword mining** — pull alphabet-expanded suggestions across the seed for your category, then filter for adjacent products or intents you want to exclude from broad-match campaigns.
- **Content gap analysis** — query your brand + competitor names across `en`-`us`, `en`-`gb`, `en`-`au` to find geo-specific concerns and product comparisons real users are searching for.
- **Multi-market localisation research** — query the same product seed across 5–10 locales to see how local users phrase the same intent in their language; informs product copy, landing pages, and marketplace listings.
- **Trend monitoring** — schedule a recurring run on a fixed seed list and diff the suggestion list day-over-day to detect emerging interest spikes before they hit the SERP.
- **AI training-data curation** — bulk-export real human search phrasings for fine-tuning intent classifiers or query-understanding models; the suggestions are post-processed real queries, free from PII.
- **Free keyword research API replacement** — developers who were paying per-call for a keyword research API can replace that spend with a single Apify Actor at $1.20 per 1,000 results.

### ⚙️ How to use it

1. Open the Actor input form.
2. Enter your **Seed queries** — one per line (e.g. `best laptop`, `best espresso machine`, `learn python`).
3. Optionally set **Language codes** and **Country codes**. Both default to `["en"]` / `["us"]`. Use 2-letter lowercase codes (ISO-639-1 for languages, ISO-3166-1 alpha-2 for countries). For multi-locale runs, add several to each list.
4. Pick a **Suggest client**. `chrome` (default) is recommended — it returns up to 15 suggestions with relevance scores. `firefox` is leaner (up to 10 suggestions, no scores).
5. Set **Max suggestions per seed** if you want fewer than the API maximum (default 10, max 15).
6. Toggle **Enable A–Z alphabet expansion** if you want long-tail discovery — each seed will generate 26 extra queries (`<seed> a` through `<seed> z`).
7. Leave **Use Apify Proxy** off for most runs; enable it for large jobs (>2,000 tuples) if you encounter rate limits.
8. Click **Start**. Results stream into the default dataset and can be exported as JSON, CSV, Excel, or XML.

#### Single-seed example

```json
{
  "seeds": ["best laptop"],
  "languages": ["en"],
  "countries": ["us"],
  "client": "chrome",
  "maxSuggestionsPerSeed": 10,
  "enableAlphabetExpansion": false,
  "useProxy": false
}
```

#### Multi-locale + alphabet expansion example

```json
{
  "seeds": ["best laptop", "best espresso machine"],
  "languages": ["en", "de"],
  "countries": ["us", "de"],
  "client": "chrome",
  "maxSuggestionsPerSeed": 15,
  "enableAlphabetExpansion": true,
  "useProxy": false
}
```

This produces `2 seeds × 2 languages × 2 countries × (1 + 26) variants × 15 rows = up to 3,240 rows`.

### 📥 Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `seeds` | array<string> | yes | — | 1–500 seed queries |
| `languages` | array<string> | no | `["en"]` | ISO-639-1 lowercase language codes |
| `countries` | array<string> | no | `["us"]` | ISO-3166-1 alpha-2 lowercase country codes |
| `client` | string (enum) | no | `chrome` | `chrome` (up to 15 suggestions + scores) or `firefox` (up to 10) |
| `maxSuggestionsPerSeed` | integer | no | `10` | 1–15 |
| `enableAlphabetExpansion` | boolean | no | `false` | If true, also query `<seed> a` through `<seed> z` |
| `useProxy` | boolean | no | `false` | Route through Apify Proxy (a datacenter proxy pool) |

### 📤 Output

One row per suggestion. All seed / locale / provenance fields denormalised onto every row so a flat CSV is self-contained.

```json
{
  "seed": "best laptop",
  "suggestion": "best laptop 2026",
  "position": 1,
  "relevance": 900,
  "subtype": "QUERY",
  "language": "en",
  "country": "us",
  "client": "chrome",
  "is_expansion": false,
  "parent_seed": null,
  "scraped_at": "2026-05-16T12:00:00.000Z"
}
```

When alphabet expansion is enabled, expanded rows carry `is_expansion=true` and `parent_seed` set to the original seed:

```json
{
  "seed": "best laptop a",
  "suggestion": "best laptop accessories",
  "position": 0,
  "relevance": 1250,
  "subtype": "QUERY",
  "language": "en",
  "country": "us",
  "client": "chrome",
  "is_expansion": true,
  "parent_seed": "best laptop",
  "scraped_at": "2026-05-16T12:00:00.000Z"
}
```

#### Export formats

- **JSON** — full fidelity, all fields, newline-delimited
- **CSV** — flat, one row per suggestion, all columns
- **Excel** — `.xlsx` via the Apify dataset converter
- **XML** — structured per-item

All formats are available via the Apify API: `GET /datasets/{id}/items?format=csv&clean=true`.

### 💰 Pricing

No Actor start fee. You pay for the output events below.

| Event | USD per event | Billing unit |
|---|---:|---|
| `result-row` | $0.001 | Charged per autocomplete suggestion row written to the dataset. |

1,000 output events cost **$1.00** at the standard rate, with no start charge.

Existing subscriber discounts remain available in the Apify Pricing tab.

### 🚧 Limitations

- **Suggest endpoint, not SERP.** This Actor returns autocomplete suggestions — the dropdown under the search box. It does not scrape the actual Google search results page. For SERP scraping use a dedicated SERP Actor.
- **No search-volume data.** Google Suggest does not return monthly search-volume estimates — only the suggestions themselves. Pair with a keyword-volume Actor or Google Keyword Planner for volume.
- **Locale is a request hint, not a guarantee.** Google may return general suggestions when locale-specific signal is sparse; obscure seeds in long-tail locales may return small or empty suggestion lists.
- **A–Z expansion only.** This Actor expands seeds with `a..z` suffixes. Number suffixes (`0..9`), question modifiers (`why`, `how`, `when`), or comparison modifiers (`vs`, `or`) are not built-in — they can be passed as explicit seeds.
- **Concurrency capped at 2.** The Actor deliberately limits in-flight requests to stay well within the Suggest endpoint's tolerances. Very large runs (10k+ tuples) will take time; budget accordingly.
- **7-day default storage retention** on the Apify FREE tier. Export your dataset immediately after the run or upgrade for longer retention.
- **No private / signed-in suggestions.** Personalised suggestions tied to a Google account are out of scope — this Actor reflects the unauthenticated public Suggest endpoint.

### ❓ FAQ

**Where do these suggestions come from?**

Directly from Google's public Suggest endpoint at `suggestqueries.google.com/complete/search` — the same endpoint Chrome and Firefox call when you type in the address bar. The response is a JSON array of up to 15 suggestions per query (chrome client) or 10 (firefox client).

**Is this a google suggest scraper or does it use an official API?**

The endpoint is a public, browser-facing API — not a signed Google Cloud product. It has no API key requirement and is designed for browser clients. We treat it like what it is: a well-known endpoint that can throttle heavy callers. That is why we run conservative concurrency and retry with backoff so you get reliable bulk output.

**What is alphabet expansion and why does it matter?**

Alphabet expansion is the canonical long-tail discovery technique used by every major keyword-research tool. For each seed, the Actor also queries `<seed> a`, `<seed> b`, …, `<seed> z` — 26 extra calls. This surfaces the most common queries that start with your seed plus any next letter. For example, `best laptop` returns 15 generic suggestions; `best laptop a` returns suggestions like "best laptop accessories", "best laptop antivirus"; `best laptop b` returns "best laptop brands", "best laptop bag", and so on. One seed × 26 letters × 15 suggestions = up to 390 long-tail keywords per locale.

**Should I pick chrome or firefox?**

`chrome` (default) is the better choice for most use cases — it returns up to 15 suggestions (50% more than firefox), plus the `google:suggestrelevance` score (which loosely correlates with search-volume signal) and `google:suggesttype` tags. Pick `firefox` only when you specifically want the leaner 10-result payload without scores.

**Do I need Apify Proxy for every run?**

Not for typical runs. The Actor runs at conservative concurrency (2 in-flight requests) with automatic retry on rate-limit responses. Enable `useProxy` for very large alphabet-expansion jobs (>2,000 tuples) — the Actor will route through Apify Proxy.

**How many requests does one run make?**

`len(seeds) × len(languages) × len(countries) × (1 + 26 if alphabet expansion else 1)` API calls. Each call returns up to 15 rows. So 10 seeds × 1 locale × A–Z = 270 calls → up to 4,050 rows.

**Is this an AnswerThePublic alternative?**

Yes, it hits the same underlying Google Suggest data source that powers AnswerThePublic, KeywordTool.io, and Ubersuggest. The difference: you get raw bulk export across any locale or seed list at $1.20 per 1,000 suggestions instead of a fixed SaaS monthly seat. No dashboard, no limit on seed volume.

**Is this legal?**

The Google Suggest endpoint is a public, unauthenticated HTTP API designed for browsers and developer tools to embed Google autocomplete in their UIs. Always verify your jurisdiction's data-protection rules and Google's Terms of Service before reselling raw suggestion data — most commercial keyword-research products use this same endpoint under the same conditions.

### 💬 Your feedback

Found a bug, hit a rate limit, or need a new field on the output row? Open an issue on the Actor's Apify Store page or contact the Devil Scrapes team at [apify.com/DevilScrapes](https://apify.com/DevilScrapes). We ship updates within days of validated reports.

# Changelog

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

# Actor input Schema

## `seeds` (type: `array`):

1–500 seed queries. The Actor fans each seed across every language × country combination below.

## `languages` (type: `array`):

ISO-639-1 lowercase language codes used for the <code>hl</code> parameter (e.g. <code>en</code>, <code>de</code>, <code>fr</code>, <code>ja</code>).

## `countries` (type: `array`):

ISO-3166-1 alpha-2 lowercase country codes used for the <code>gl</code> parameter (e.g. <code>us</code>, <code>de</code>, <code>gb</code>, <code>jp</code>).

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

Suggest endpoint client variant. <code>chrome</code> returns up to 15 suggestions plus relevance scores and subtypes (richest). <code>firefox</code> returns up to 10 suggestions with a leaner payload.

## `maxSuggestionsPerSeed` (type: `integer`):

Cap suggestions returned per (seed × language × country) tuple. Applied after the API response is parsed; never multiplies API calls.

## `enableAlphabetExpansion` (type: `boolean`):

If enabled, also query <code>\<seed> a</code>, <code>\<seed> b</code>, …, <code>\<seed> z</code> per seed — 26 extra calls per seed × locale for deep long-tail discovery.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy (a static US datacenter pool). Google Suggest is generally tolerant of datacenter IPs — leave disabled unless you are hitting rate limits.

## Actor input object example

```json
{
  "seeds": [
    "best laptop",
    "best espresso machine"
  ],
  "languages": [
    "en"
  ],
  "countries": [
    "us"
  ],
  "client": "chrome",
  "maxSuggestionsPerSeed": 10,
  "enableAlphabetExpansion": false,
  "useProxy": false
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "seeds": [
        "best laptop",
        "best espresso machine"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/google-autocomplete-bulk").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 = { "seeds": [
        "best laptop",
        "best espresso machine",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/google-autocomplete-bulk").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 '{
  "seeds": [
    "best laptop",
    "best espresso machine"
  ]
}' |
apify call devilscrapes/google-autocomplete-bulk --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,devilscrapes/google-autocomplete-bulk"
        }
    }
}
```

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/yA11McGOBjOUnZmgB/builds/q4VxG2NqnU4aYohFX/openapi.json