# Google Autocomplete Scraper & YouTube Suggest \[USD 0.05/1K] (`usefulapi/google-autocomplete-scraper`) Actor

Google & YouTube autocomplete keyword suggestions with relevance scores, for keyword research and long-tail ideas: a-z, questions, depth 1-3, many countries in one run with a comparison table, intent tags, new/dropped tracking. USD 0.05/1K suggestions + USD 0.02/1K queries, no start fee.

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

## Pricing

from $0.05 / 1,000 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/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 and Suggest API: keyword suggestions from Google and YouTube

Get the **keyword suggestions Google shows as people type** (long-tail keywords for keyword research, content and PPC), for any seed keyword, in any country and language, from
**Google web search and YouTube**. Every suggestion comes back as a clean row with its position, **Google's own
relevance score**, the suggestion type, simple intent tags (question, comparison, commercial, local) and the exact
query that produced it. Export to JSON, CSV or Excel, or call it as a Google Suggest API.

Built for SEO specialists, content writers, PPC managers and YouTube creators.

**USD 0.05 per 1,000 suggestions + USD 0.02 per 1,000 queries. No start fee**, so a one-keyword check costs a fraction
of a cent.

### What this Google autocomplete scraper does

- **Google and YouTube autocomplete** in one run (pick one or both), each row labelled with its engine.
- **Expansions** that turn one seed into hundreds of long-tail keywords:

  - **a-z**: `seed a`, `seed b` ... `seed z` (26 queries)
  - **0-9**: `seed 0` ... `seed 9` (10 queries)
  - **questions**: `how seed`, `what seed`, `why seed`, `can seed`, `is seed`...
  - **prepositions**: `seed for`, `seed with`, `seed without`, `seed near`...
  - **comparisons**: `seed vs`, `seed versus`, `seed or`, `seed alternative`...
  - **your own prefixes and suffixes**: `cheap seed`, `seed 2026`, `seed for beginners`...

  Question, preposition and comparison words are built in for **English, Spanish, French, German, Portuguese, Italian
  and Dutch** and follow the language of each query (`cómo`, `comment`, `wie`, `come`, `hoe`...).
- **Depth 1 to 3**: at depth 2 the top suggestions of every answer are sent back to Google as new queries, at depth 3
  once more. You choose how many per answer (1 to 15).
- **Many countries and languages in one run**, with a **country comparison table**: every suggestion with its position
  in each country, the countries where it never appears and a flag for suggestions found in one country only.
- **Changes since the last run**: switch on tracking and every row gets `isNew`, and the run writes a report of the
  suggestions that are **new and the ones that dropped out** since the last run. Built for scheduled runs. Optionally
  save only the new ones.
- **Deduplicated per seed, engine, country and language**, with `timesSeen` (how many of the run's queries returned
  the same suggestion) and `bestPosition`.
- **Correct accents**: suggestions are requested in UTF-8 (without it Google answers in ISO-8859-1), so `café près de
  moi` and `müller öffnungszeiten` come back intact (tested with French and German).
- **Hard caps** on queries and suggestions per run, and polite pacing towards Google (a few requests at a time, slowing
  down on its own if Google asks).

### YouTube autocomplete keywords

Add `youtube` to engines and the same seeds, expansions and countries run against YouTube's search box. YouTube
suggestions are often very different from Google web for the same seed: in a test, "best crm" on YouTube gave
"best crm for cleaning business" and "best crm for pressure washing", while Google web gave "best crm for real estate"
and "best crm for nonprofits". Each row says which engine it came from, so one run covers web and video SEO.

### Keyword research examples

One keyword, questions only (the default prefill):

```json
{
  "keywords": ["keyword research"],
  "engines": ["google"],
  "countries": ["us"],
  "languages": ["en"],
  "expansions": ["questions"]
}
```

Full keyword map for two seeds on Google and YouTube:

```json
{
  "keywords": ["running shoes", "trail running"],
  "engines": ["google", "youtube"],
  "countries": ["us"],
  "languages": ["en"],
  "expansions": ["az", "digits", "questions", "prepositions", "comparisons"],
  "customSuffixes": ["2026", "reddit"]
}
```

Same seed in four English-speaking countries, with the comparison table:

```json
{
  "keywords": ["how to apply for a"],
  "countries": ["us", "gb", "au", "in"],
  "languages": ["en"],
  "expansions": ["az"]
}
```

Each country in its own language (`auto`):

```json
{
  "keywords": ["café"],
  "countries": ["fr", "de", "es", "br"],
  "languages": ["auto"],
  "expansions": ["questions", "prepositions"]
}
```

Weekly monitoring of what Google suggests after a brand name (schedule it in Apify):

```json
{
  "keywords": ["notion"],
  "engines": ["google", "youtube"],
  "countries": ["us", "gb"],
  "expansions": ["az", "comparisons"],
  "trackChanges": true,
  "trackingName": "notion-weekly"
}
```

Deep long-tail tree:

```json
{
  "keywords": ["crm"],
  "expansions": ["az"],
  "depth": 2,
  "expandTop": 5,
  "maxQueries": 1000
}
```

### Output

One row per unique suggestion (per seed, engine, country and language):

```json
{
  "seed": "running shoes",
  "suggestion": "running shoes near me",
  "engine": "google",
  "country": "us",
  "language": "en",
  "expansion": "seed",
  "modifier": null,
  "query": "running shoes",
  "depth": 1,
  "position": 5,
  "bestPosition": 3,
  "timesSeen": 4,
  "relevance": 560,
  "suggestType": "QUERY",
  "intent": [
    "local"
  ],
  "containsSeed": true,
  "wordCount": 4,
  "scrapedAt": "2026-11-03T15:26:43.660Z"
}
```

| Field | What it is |
|---|---|
| `seed` | Your keyword |
| `suggestion` | What Google suggested |
| `engine` | `google` or `youtube` |
| `country`, `language` | The `gl` and `hl` sent to Google |
| `expansion`, `modifier` | How the query was made: `seed`, `a-z`, `0-9`, `question`, `preposition`, `comparison`, `custom-prefix`, `custom-suffix` or `recursive`, and the letter or word added |
| `query` | The exact text sent to Google |
| `depth` | 1 for the seed and its expansions, 2 and 3 for depth queries |
| `position` | Position (1-15) in the answer that first returned it |
| `bestPosition`, `timesSeen` | Best position and number of answers that returned it, across the run's queries for this seed, engine, country and language (can undercount on seeds with more than 2,000 suggestions) |
| `relevance` | Google's own relevance score for the suggestion (higher ranks higher; not a search volume) |
| `suggestType` | Google's suggestion type, usually `QUERY`; also `ENTITY`, and `NAVIGATION` / `CALCULATOR` when you keep them |
| `intent` | `question`, `comparison`, `commercial`, `local` (see below) |
| `containsSeed` | Every word of the seed appears in the suggestion text ("shoe" counts as found in "shoes"). False means Google suggested something else, for example a spelling fix |
| `wordCount` | Words counted by spaces; in Thai, Japanese and Chinese each part between spaces counts as one word |
| `isNew` | With tracking on: not in the last run's suggestions for this seed, engine, country and language |
| `description` | Only for website suggestions: the page title Google shows |

Dataset views: **Suggestions**, **Keyword list (SEO)** and **How each suggestion was found**.

#### Country comparison (2 or more countries or languages)

Written to the run's key-value store as `COUNTRY_COMPARISON` (JSON) and `COUNTRY_COMPARISON_CSV`:

```csv
seed,engine,suggestion,found_in,of,unique_to,us-en,gb-en
running shoes,google,running shoes for men,2,2,,2,1
running shoes,google,running shoes near me,2,2,,3,6
running shoes,google,running shoes for flat feet,2,2,,8,12
running shoes,google,affordable brooks running shoes alternatives,2,2,,x,x
```

A number is the position in Google's answer to the seed itself in that country, `x` means only an expansion or depth
query found it there, and an empty cell means it was not suggested there at all. In a test run on Apify (3 November
2026\) "how to apply for a" gave each country its own answers: passport and credit card in the US, Blue Badge and
attendance allowance in the UK, Australian passport and Medicare card in Australia, Ayushman card in India.

#### Changes report (tracking on)

`CHANGES` lists, per seed, engine, country and language: whether it is the first run, how many suggestions are new and
how many dropped out, and the suggestions themselves (up to 1,000 of each). The history is kept in a key-value store
named `google-autocomplete-tracking` on your own Apify account, one list per tracking name.

#### Intent tags

Plain word rules, so you can check every tag by eye:

- **question**: starts with a question word (how, what, why, can, is... / cómo, comment, wie, come, hoe...), contains
  how/what/why/where/when/which, or ends with `?`
- **comparison**: vs, versus, compare, alternative(s), difference between, better than (and the same words in the other
  six languages)
- **commercial**: best, top, cheap, buy, price, cost, deal, discount, coupon, review(s), for sale, rent, hire, shop...
- **local**: near me, nearby, close to me, open now, in my area (près de moi, in der nähe, cerca de mí...)

Tags are built in for English, Spanish, French, German, Portuguese, Italian and Dutch. In other languages only `vs`,
`versus` and a trailing `?` are tagged.

### Pricing

Pay per event, no subscription, **no run-start fee**:

| Event | Price | Per 1,000 |
|---|---|---|
| Suggestion (one unique suggestion saved) | USD 0.00005 | USD 0.05 |
| Query (one autocomplete request Google answered) | USD 0.00002 | USD 0.02 |

What real runs cost (measured 3 November 2026):

| Run | Queries | Suggestions | Price |
|---|---|---|---|
| 1 keyword, questions (the prefill) | 14 | 102 | USD 0.0054 |
| 2 keywords x Google + YouTube x 4 countries, a-z + comparisons | 544 | 6,896 | USD 0.36 |
| 1 keyword, a-z, depth 3, 15 per answer, stopped at 2,000 queries | 2,000 | 11,214 | USD 0.60 |

Set a **maximum cost per run** in Apify and the scraper stops cleanly before it, with every row so far saved. With
"Save only new suggestions" you pay only for the new ones (plus the queries).

### Good to know

- **"Near me" and city suggestions follow the server's location, not the country.** The `gl` country code changes the
  national suggestions (tested: the same seed gave different answers in the US, UK, Australia and India), but
  city-level suggestions such as "restaurants near ..." depend on where the request comes from, so they are **not
  location-accurate** for your target city. Example from a test run on Apify's servers: Google's US answer for
  "running shoes" included "running shoes alexandria va" and "running shoes frederick md": towns picked from the server's location, not from the buyer's.
- Autocomplete has **no search volume**. `relevance`, `position` and `timesSeen` show how strongly Google suggests a
  phrase, not how many people search it.
- Suggestions change by the hour; two runs on the same input are not guaranteed to be identical (which is what the
  changes report is for).
- Website (`NAVIGATION`) and calculator suggestions are left out and not billed unless you switch them on.
- Depth multiplies queries: 1 seed with a-z at depth 2 and 5 per answer is up to 27 + 135 queries (texts already asked are skipped). `maxQueries`
  (up to 20,000) and `maxSuggestions` (up to 100,000) always cap the run.
- If Google refuses several queries in a row even after waiting, the run stops politely with the rows so far; run the
  rest later.
- No personal data: the input is your keywords and the output is the suggestions Google shows to everyone.
- Amazon, Bing and DuckDuckGo suggestions are not included.

### Use it as a Google Suggest API

```bash
curl -X POST "https://api.apify.com/v2/acts/usefulapi~google-autocomplete-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["keyword research"],"countries":["us"],"expansions":["questions"]}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("usefulapi/google-autocomplete-scraper").call(run_input={
    "keywords": ["keyword research"],
    "countries": ["us", "gb"],
    "expansions": ["az", "questions"],
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["country"], row["position"], row["suggestion"])
```

Large runs take minutes; `run-sync-get-dataset-items` waits at most 300 seconds, so for big inputs start the run with
`.call()` (as in the Python example) or the async run endpoint and read the dataset when it finishes.

**AI agents (MCP):** like any Apify Actor it can be called by AI agents through Apify's MCP server, so an assistant can
pull fresh keyword suggestions on its own.

**Schedules and integrations:** run it daily or weekly with Apify Schedules (with tracking on, each run reports what is
new and what dropped out) and send the results to Google Sheets, Make, Zapier or a webhook with Apify's integrations.

### FAQ

**Is it legal to scrape Google autocomplete?** The suggestions are public text that Google shows to everyone; this
Actor sends no login, no cookies and no personal data, keeps a slow pace, and stops when Google says no.
`suggestqueries.google.com` has no robots.txt rules. Check Google's terms and the law where you use the data; this is
not legal advice.

**Is this the Google Suggest API?** It reads Google's public autocomplete endpoint (`suggestqueries.google.com`), with
no API key and no login. Google does not publish it as an official API.

**How many suggestions per query?** Up to 15, for Google web and for YouTube (every seed answer in our Apify test runs
had 15).

**What is the relevance score?** The number Google attaches to each suggestion in its answer, for Google web and
YouTube alike (between 550 and 1261 in our test runs, higher for the top suggestions). It is Google's ranking signal,
not a search volume.

**Can I get YouTube keyword ideas?** Yes, add `youtube` to engines. YouTube suggestions often differ a lot from Google
web suggestions for the same seed.

**Which countries and languages?** Any two-letter country code (`uk` is read as `gb`) and Google language codes such as
`en`, `de`, `pt-BR`, passed to Google as written. With `auto`, each country uses its main language (built in for 87
countries; Belgium uses `nl`, Switzerland `de`). Countries x languages is capped at 50 combinations per run.

**Can I schedule it?** Yes. Use Apify Schedules with tracking on, and each run tells you what is new and what dropped
out since the previous one.

**Why is a suggestion missing that I see in my browser?** Google personalises the box in your browser (history,
location, signed-in account); this scraper asks without any of that.

# Actor input Schema

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

One keyword per line, in any language: <code>keyword research</code>, <code>best running shoes</code>, <code>café près</code>. Each seed is sent to Google exactly as written, plus the expansions you pick below. Up to 1,000 seeds of up to 200 characters per run; duplicates are dropped.

## `engines` (type: `array`):

<b>google</b> = Google web search suggestions. <b>youtube</b> = YouTube search suggestions. Pick both to get both in one dataset, each row labelled with its engine.

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

Two-letter country codes (Google's <code>gl</code>): <code>us</code>, <code>gb</code>, <code>de</code>, <code>in</code>... Up to 50. With two or more countries the run also writes a <b>country comparison table</b>: every suggestion with its position in each country and which countries never show it. City-level suggestions such as "near me" follow the server's location, not the country, so they are not location-accurate. <code>uk</code> is read as <code>gb</code>.

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

Google interface language codes (<code>hl</code>): <code>en</code>, <code>de</code>, <code>pt-BR</code>, <code>ja</code>..., passed to Google as written. Every country is run in every language listed (at most 50 combinations per run). <code>auto</code> = each country's main language (built in for 87 countries, e.g. us en, de de, br pt-BR, jp ja, be nl, ch de); for a country without one the run stops and asks for a code.

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

Extra queries made from each seed. <b>az</b>: seed + a to z (26 queries). <b>digits</b>: seed + 0 to 9 (10). <b>questions</b>: how, what, why... + seed (10 to 13). <b>prepositions</b>: seed + for, with, without, near... (9 to 13). <b>comparisons</b>: seed + vs, versus, or, alternative... (7). Question, preposition and comparison words are built in for English, Spanish, French, German, Portuguese, Italian and Dutch, and follow the language of each query; for other languages use your own prefixes and suffixes. Every query Google answers is billed as one query event. Leave empty (the API default) to send only the seeds themselves.

## `customPrefixes` (type: `array`):

Words put before every seed, one query each: <code>cheap</code>, <code>buy</code>. Up to 50 words of up to 50 characters.

## `customSuffixes` (type: `array`):

Words put after every seed, one query each: <code>2026</code>, <code>for beginners</code>, <code>reddit</code>. Up to 50 words of up to 50 characters.

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

1 = the seed and its expansions only. 2 = also ask Google about the top suggestions found (see next field). 3 = once more. Each level multiplies the number of queries, so keep Max queries in mind.

## `expandTop` (type: `integer`):

At depth 2 and 3, how many of the top suggestions of each answer are sent back to Google as new queries.

## `maxQueries` (type: `integer`):

Hard cap on queries sent to Google in this run (seed, expansion and depth queries together; a retry of the same query after Google asks to slow down is not counted again). The run stops cleanly when it is reached; everything found so far is saved.

## `maxSuggestions` (type: `integer`):

Hard cap on suggestion rows saved (and billed) in this run.

## `keepUrlAndCalculatorSuggestions` (type: `boolean`):

Google sometimes suggests a website address (type NAVIGATION, e.g. https://www.facebook.com/) or a calculator answer ("= 4"). They are not searches, so they are left out (and not billed) unless you switch this on.

## `trackChanges` (type: `boolean`):

Remembers this run's suggestions (per seed, engine, country and language) on your Apify account. Every row gets <code>isNew</code>, and the run writes a <b>CHANGES</b> report with the suggestions that are new and the ones that <b>dropped out</b> since the last run with the same tracking name. Made for scheduled runs.

## `onlyNew` (type: `boolean`):

Needs tracking switched on. Saves (and bills) only suggestions that were not there last time; the first run saves everything. Queries are billed as usual.

## `trackingName` (type: `string`):

Keeps separate histories apart, e.g. one per client or project. Letters, digits and hyphens, up to 40 characters.

## Actor input object example

```json
{
  "keywords": [
    "keyword research"
  ],
  "engines": [
    "google"
  ],
  "countries": [
    "us"
  ],
  "languages": [
    "en"
  ],
  "expansions": [
    "questions"
  ],
  "depth": 1,
  "expandTop": 5,
  "maxQueries": 2000,
  "maxSuggestions": 20000,
  "keepUrlAndCalculatorSuggestions": false,
  "trackChanges": false,
  "onlyNew": false,
  "trackingName": "default"
}
```

# Actor output Schema

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

No description

## `keywords` (type: `string`):

No description

## `comparison` (type: `string`):

No description

## `comparisonCsv` (type: `string`):

No description

## `changes` (type: `string`):

No description

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

No description

# 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": [
        "keyword research"
    ],
    "engines": [
        "google"
    ],
    "countries": [
        "us"
    ],
    "languages": [
        "en"
    ],
    "expansions": [
        "questions"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("usefulapi/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": ["keyword research"],
    "engines": ["google"],
    "countries": ["us"],
    "languages": ["en"],
    "expansions": ["questions"],
}

# Run the Actor and wait for it to finish
run = client.actor("usefulapi/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": [
    "keyword research"
  ],
  "engines": [
    "google"
  ],
  "countries": [
    "us"
  ],
  "languages": [
    "en"
  ],
  "expansions": [
    "questions"
  ]
}' |
apify call usefulapi/google-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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