# Google Autocomplete Scraper: Keyword Suggestions, YouTube (`ctriolab/google-autocomplete-scraper`) Actor

Get Google Autocomplete keyword suggestions for many seeds, countries and languages: A to Z, 0 to 9, questions, prepositions, recursive depth 0 to 3, Google web, YouTube and Shopping. Up to 15 per query with relevance score, only new suggestions mode. $0.10 per 1,000.

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

## Pricing

from $0.07 / 1,000 suggestions

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Google Autocomplete Scraper: Keyword Suggestions, YouTube

Turn a few seed keywords into hundreds or thousands of long-tail keyword ideas from Google Autocomplete, the predictions people see while they type.

- **$0.10 per 1,000 suggestions** on the Free plan ($0.07 on Gold and up), plus $0.00005 per run. Platform usage is about $0.005 per 1,000 suggestions. Duplicate suggestions in a run are saved and charged once.
- **Up to 15 suggestions per query** with Google's own **relevance score** and position.
- **Expansions**: A to Z, 0 to 9, questions (how, what, why, when, where, who, which, can, is, does, are, will) and prepositions (for, with, without, vs, near, to).
- **Recursive depth 0 to 3**: query every suggestion again to build a keyword tree. Every row tells you the seed, the exact query, the expansion and the depth.
- **Google web search, YouTube and Google Shopping** autocomplete, each with its own list.
- **Many countries and languages in one run**: US:en, GB:en, DE:de, BR:pt-BR, KR:ko and any other pair.
- **Only new suggestions**: schedule it daily and pay only for suggestions that did not appear before.
- Fast and light: 20 seeds with A to Z and 0 to 9 plus one level of depth gave 20,000 unique suggestions in 84 seconds on 256 MB, with zero rate limits and no proxy.

### How much does it cost?

| Run | Queries | Unique suggestions | Cost on the Free plan |
|---|---|---|---|
| 1 seed, A to Z | 27 | about 380 | about $0.04 |
| 3 seeds, A to Z | 81 | about 1,100 | about $0.12 |
| 20 seeds, A to Z and 0 to 9, depth 1 (stopped at Max results) | 1,594 | 20,000 | about $2.09 |

Price per saved suggestion: Free $0.0001, Bronze $0.00009, Silver $0.00008, Gold, Platinum and Diamond $0.00007, plus $0.00005 per run start. Queries that fail are free. Set **Max results** or a run charge limit to cap the cost.

### Quick start

1. Add your **Keywords**, for example `coffee maker`.
2. Pick **Expansions** (A to Z is on by default) and, if you like, **Recursive depth**.
3. Add **Countries and languages** and **Sources** if you need more than Google web search in US English.
4. Click **Start** and download the results as JSON, CSV or Excel, or read them through the API.

Running with no input at all is a small demo: `coffee` with A to Z in US English.

### Example input

```json
{
  "keywords": ["coffee maker", "running shoes"],
  "markets": ["US:en", "GB:en"],
  "sources": ["web", "youtube"],
  "expansions": ["alphabet", "questions"],
  "maxDepth": 1,
  "maxResults": 5000
}
```

### Example output

One row per unique suggestion:

```json
{
  "suggestion": "coffee maker with timer",
  "seedKeyword": "coffee maker",
  "parentQuery": "coffee maker w",
  "expansion": "* w",
  "position": 6,
  "depth": 0,
  "source": "web",
  "country": "US",
  "language": "en",
  "relevance": 559,
  "changeStatus": null,
  "scrapedAt": "2026-11-05T04:10:36.461Z"
}
```

| Field | Meaning |
|---|---|
| suggestion | The autocomplete prediction. |
| seedKeyword | The keyword from your input it came from. |
| parentQuery | The exact text sent to Google. |
| expansion | `none` (the seed itself), `* a` (suffix), `how *` (prefix) or `recursive` (a deeper level). |
| position | Place in Google's list for that query, 1 is first. |
| depth | 0 for the seed and its expansions, 1 to 3 for recursive levels. |
| source | `web`, `youtube` or `shopping`. |
| country, language | The market you asked for. |
| relevance | Google's suggest relevance score (higher is stronger), when Google returns it. |
| changeStatus | `new` in Only new suggestions mode, otherwise null. |

The run's `SUMMARY` record has the number of queries, failed queries (not charged), retries and why the run stopped.

### FAQ

**Is it the same as what I see in my browser?** It reads the same public suggest service. Results depend on country, language and time, and Google personalizes your own browser by history, so small differences are normal.

**Why do I get more than 10 suggestions per query?** The Actor asks for the full list Google returns to Chrome, usually 15.

**Do I need a proxy?** Usually not. The Actor waits and retries on rate limits (HTTP 429) with backoff and Retry-After. For very large runs you can turn on Apify Proxy and the Actor changes IP on every retry.

**How do I watch new keywords every day?** Turn on **Only new suggestions**, give the list a **Monitor name** and schedule the task. Suggestions already saved for that monitor name are skipped and not charged.

**Are web addresses included?** No. Navigation suggestions that are only a URL (for example `http://apify.com`) are dropped, so every row is a keyword.

**Can I use it from code or AI agents?** Yes: through the Apify API, the Python and JavaScript clients, integrations like Make, Zapier and n8n, or the Apify MCP server.

### More keyword data from Ctrio Lab

- [Google Trends Scraper](https://apify.com/ctriolab/google-trends-scraper): interest over time, interest by region, related queries and topics, and Trending now. Check which of your autocomplete ideas are growing.

### Your responsibility

This Actor reads Google's public autocomplete suggestions. It does not log in, does not solve CAPTCHAs and does not hide what it is: every request names the Actor in its User-Agent and it slows down when Google asks it to. You are responsible for how you use the data and for following the terms that apply to you.

### Support

Questions or ideas? Open an issue on the Actor page or write to help@ctriolab.com.

# Actor input Schema

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

Seed keywords. Each one is sent to Google Autocomplete as it is and with the expansions you choose below. With no keywords field at all the Actor runs a small demo for "coffee".

## `markets` (type: `array`):

One country:language pair per line, for example US:en, GB:en, DE:de, BR:pt-BR, KR:ko. A country alone means English. Empty = US:en.

## `sources` (type: `array`):

Which autocomplete to read. Google web search, YouTube search or Google Shopping. Each gives its own list.

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

Extra queries per seed. A to Z: "coffee a" ... "coffee z". 0 to 9: "coffee 0" ... "coffee 9". Questions: "how coffee", "what coffee", "why coffee" and 9 more. Prepositions: "coffee for", "coffee with", "coffee without", "coffee vs", "coffee near", "coffee to". The seed itself is always queried.

## `maxDepth` (type: `integer`):

0 = only the seeds and their expansions. 1 = also query every suggestion found, 2 and 3 go further. Deeper levels grow fast, so keep Max results set.

## `maxResults` (type: `integer`):

Stop after this many unique suggestions are saved. You pay only for saved suggestions.

## `onlyNewSuggestions` (type: `boolean`):

Remember the suggestions saved by earlier runs with the same monitor name and save only ones that are new. Known suggestions are not saved and not charged. Schedule it daily to watch what people start searching for.

## `monitorName` (type: `string`):

Separate memory for each list you watch. Used only with Only new suggestions.

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

Not needed in most runs: Google Autocomplete answers without a proxy and the Actor slows down on rate limits. Turn on Apify Proxy for very large runs if you see many retries in the run summary.

## Actor input object example

```json
{
  "keywords": [
    "coffee"
  ],
  "markets": [
    "US:en"
  ],
  "sources": [
    "web"
  ],
  "expansions": [
    "alphabet"
  ],
  "maxDepth": 0,
  "maxResults": 1000,
  "onlyNewSuggestions": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per unique suggestion with the seed keyword, the query that produced it, position, depth, source, country, language and relevance.

## `summary` (type: `string`):

Counts, failed queries (not charged), HTTP retries and why the run stopped.

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

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

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

```

## MCP server setup

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