# Google Autocomplete & Keyword Suggest Scraper (`memo23/google-suggest-scraper`) Actor

Scrape Google Autocomplete suggestions at scale. Seed keywords expand via A-Z, 0-9 and question prefixes across countries and languages, with Google's own relevance score per phrase. Long-tail keyword research, SEO content ideas, PPC discovery. JSON/CSV out.

- **URL**: https://apify.com/memo23/google-suggest-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** SEO tools, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 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/platform/actors/running/actors-in-store#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 Suggest Scraper

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/CaUN8XWCzisJZIatu/records/card-2x" alt="Google Autocomplete &amp; Keyword Suggest Scraper — A–Z, 0–9 and question expansion across any country and language" width="820">
</p>

Scrape **Google Autocomplete** suggestions at scale. Give it seed keywords and get back ranked long-tail phrases — expanded with A–Z and 0–9 suffixes, question prefixes (how/what/why/…), multiple countries and languages, and **Google's own relevance score** attached to every phrase. One clean row per suggestion, JSON or CSV out.

### Why use this scraper?

- **Google's relevance score included** — each suggestion carries the score Google itself uses to rank it (`client=chrome` data), not just an ordered list.
- **Real long-tail expansion** — each seed fans out through 26 letters, 10 digits, and 13 question prefixes, then optionally recurses: suggestions become new seeds (`expansionDepth`).
- **Multi-country, multi-language** — sweep `gl`/`hl` combinations in one run (e.g. US + GB + DE) and compare what Google suggests where.
- **A volume proxy nobody else exposes** — `volumeProxy` counts how many distinct query variants surfaced each phrase. A completion that recurs across suffixes, countries and depth levels is more broadly searched.
- **No API key, no login** — the endpoint is public; the actor handles pacing and budgets.

### Use cases

- **SEO keyword research** — mine long-tail and question keywords for content plans, briefs and clusters.
- **PPC discovery** — find query variants worth bidding on (or adding as negatives).
- **Content ideation** — `expandQuestions` surfaces FAQ-style queries ("can coffee grinder be used for spices") ready for articles and schema markup.
- **Market comparison** — same seed, different countries: see how demand phrasing differs by market.
- **Brand monitoring** — watch what Google autocompletes after your brand name.

### How it works

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/CaUN8XWCzisJZIatu/records/how-it-works" alt="How the Google Autocomplete scraper works — seed keywords, expand with A–Z, 0–9 and question prefixes, return clean deduplicated rows" width="820">
</p>

Each seed keyword is queried against Google's own autocomplete endpoint, then fanned out through the expansions you enable (A–Z, 0–9, question prefixes) and, optionally, recursed — suggestions become new seeds. Every phrase comes back with Google's relevance score, deduplicated across the run.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `keywords` | array | — (required) | Seed terms, e.g. `["coffee grinder"]` |
| `expandAlphabet` | boolean | `false` | Append a–z to each seed |
| `expandNumbers` | boolean | `false` | Append 0–9 to each seed |
| `expandQuestions` | boolean | `false` | Prefix how/what/why/where/when/which/who/can/is/vs/for/without/near |
| `expansionDepth` | integer | `0` | Feed discovered suggestions back as new seeds (keyword tree) |
| `regions` | array | `["US"]` | ISO country codes → Google `gl` param |
| `languages` | array | `["en"]` | Language codes → Google `hl` param |
| `maxSuggestionsPerKeyword` | integer | `0` | Per-seed cap after ranking (0 = no cap) |
| `maxItems` | integer | `1000` | Hard cap on total rows |
| `deduplicateSuggestions` | boolean | `false` | One row per unique phrase across seeds |
| `includeMetadata` | boolean | `true` | Include Google's suggestion type per row |
| `maxConcurrency` | integer | `10` | Parallel requests |
| `proxy` | object | — | Optional; the endpoint works without one |

#### Example input

```json
{
    "keywords": ["coffee grinder"],
    "expandAlphabet": true,
    "expandQuestions": true,
    "regions": ["US", "GB"],
    "languages": ["en"],
    "maxSuggestionsPerKeyword": 100
}
```

### Output

One row per suggestion:

```json
{
    "suggestion": "coffee grinder electric",
    "seedKeyword": "coffee grinder",
    "query": "coffee grinder e",
    "country": "US",
    "language": "en",
    "rank": 1,
    "volumeProxy": 3,
    "googlePosition": 0,
    "relevance": 1252,
    "depth": 0,
    "surfacedByQueries": ["coffee grinder e", "coffee grinder"],
    "suggestType": "QUERY",
    "scrapedAt": "2026-07-29T12:00:00.000Z"
}
```

### Key output fields

| Field | Meaning |
|---|---|
| `relevance` | Google's own score for the suggestion — higher = Google ranks it stronger |
| `volumeProxy` | How many distinct query variants surfaced this phrase (relative popularity) |
| `googlePosition` | Best 0-based slot Google served it at |
| `rank` | Final rank within its seed after sorting by relevance → volume → position |
| `suggestType` | Google's tag: `QUERY`, `NAVIGATION`, `ENTITY`, … |
| `depth` | 0 = found directly from the seed; 1+ = found via recursion |

### FAQ

**Is this search volume?** No — Google Autocomplete has no official volume numbers. `relevance` is Google's internal ranking score and `volumeProxy` is a cross-variant recurrence count; together they order keywords by how strongly Google surfaces them.

**Do I need a proxy?** Usually not; the endpoint tolerates normal request volumes. Heavy multi-country runs route through per-country exits automatically.

**How many requests does a run make?** Seeds × suffix variants × countries × languages, plus recursion levels. A hard budget (5,000 fetches) and a per-level seed cap keep runs bounded; the log tells you if a budget was hit.

**Can I get question keywords only?** Enable `expandQuestions` and filter rows whose `suggestion` starts with a question word.

### Support

- **Bug or feature request?** Open a ticket on the **Issues** tab — the fastest way to reach me; I actively maintain this scraper.
- **Email:** <muhamed.didovic@gmail.com>
- **Website:** [muhamed-didovic.github.io](https://muhamed-didovic.github.io/)

### Explore More Scrapers

- [TikTok Keyword Suggestions Scraper](https://apify.com/memo23/tiktok-suggestions-scraper) — the same engine for TikTok autocomplete
- [Ubersuggest Scraper](https://apify.com/memo23/ubersuggest-scraper) — keyword metrics with volume estimates
- [Google Search Scraper](https://apify.com/memo23/google-search-scraper) — SERP, AI Overview, ads and operators
- [Ahrefs Scraper](https://apify.com/memo23/ahrefs-scraper) — DR, backlinks, keywords and traffic

### ⚠️ Disclaimer

This actor collects publicly available autocomplete data from Google for lawful purposes such as keyword research and market analysis. You are responsible for how you use the output, including compliance with Google's Terms of Service and applicable laws in your jurisdiction.

### SEO Keywords

Google autocomplete scraper, Google suggest scraper, keyword suggestion scraper, long-tail keyword research tool, Google keyword ideas, autocomplete API alternative, question keywords scraper, SEO keyword discovery, PPC keyword expansion, Google search suggestions export.

# Actor input Schema

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

Seed terms to fetch Google Autocomplete suggestions for, e.g. <code>coffee grinder</code>. Each seed produces its own ranked suggestion set.

## `expandAlphabet` (type: `boolean`):

Append every letter a–z to each seed ("coffee a", "coffee b", …) to surface hundreds of long-tail completions per seed. Multiplies the request count ~26× — keep concurrency reasonable.

## `expandNumbers` (type: `boolean`):

Append every digit 0–9 to each seed. Useful for versioned or listicle terms ("top 5", "iphone 15").

## `expandQuestions` (type: `boolean`):

Also query <code>how/what/why/where/when/which/who/can/is/vs/for/without/near + seed</code> — surfaces question-style long-tail keywords (great for FAQ/content ideas).

## `expansionDepth` (type: `integer`):

Feed returned suggestions back in as new seeds, building a keyword tree. 0 = seeds only (default). 1–2 recommended; higher values grow the request count exponentially.

## `regions` (type: `array`):

ISO 2-letter country codes, e.g. US, GB, DE. Google localises suggestions by <b>exit IP</b>, not by this value — so the actor pins the proxy exit to each region's country for genuinely different per-country results (verified: a US sweep returns English, a JP sweep returns Japanese). <b>Paying users are auto-routed through premium country-pinned residential proxies</b> (no setup needed); free users can enable Apify Proxy below for the same. Without any proxy, regions are best-effort (reflect the run's IP). A suggestion appearing across many regions earns a higher volume proxy. Defaults to \["US"].

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

Language codes to query, e.g. en, es, ar. Defaults to \["en"].

## `maxSuggestionsPerKeyword` (type: `integer`):

Cap on suggestions returned per seed keyword, applied after ranking by volume proxy. 0 = no per-seed cap.

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

Hard cap on the total number of suggestion rows pushed to the dataset (charging-aware). Default 1000.

## `deduplicateSuggestions` (type: `boolean`):

When enabled, a suggestion surfaced by multiple seeds collapses into one row (volume proxy summed). When disabled (default), one row per (seed, suggestion) keeps full seed attribution.

## `includeMetadata` (type: `boolean`):

Include Google's raw per-suggestion signals: rank, hot level, e-commerce intent, source, group ID and language.

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

Maximum simultaneous requests to Google. The endpoint is light, so 10–20 is safe.

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "expandAlphabet": false,
  "expandNumbers": false,
  "expandQuestions": false,
  "expansionDepth": 0,
  "regions": [
    "US"
  ],
  "languages": [
    "en"
  ],
  "maxSuggestionsPerKeyword": 0,
  "maxItems": 1000,
  "deduplicateSuggestions": false,
  "includeMetadata": true,
  "maxConcurrency": 10
}
```

# 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"
    ],
    "regions": [
        "US"
    ],
    "languages": [
        "en"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/google-suggest-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"],
    "regions": ["US"],
    "languages": ["en"],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/google-suggest-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 '{
  "keywords": [
    "coffee grinder"
  ],
  "regions": [
    "US"
  ],
  "languages": [
    "en"
  ]
}' |
apify call memo23/google-suggest-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/DoMYgCcJmkk0wodk5/builds/AHL30lydzuM4QtjbM/openapi.json