# Google Autocomplete Scraper (`deriverge/google-autocomplete-scraper`) Actor

Keyword ideas from Google's search suggestions in 50 countries, with YouTube, Google Shopping and Bing as extra sources. Each keyword is expanded with letters, digits, questions and prepositions, and each phrase shows how often it came up.

- **URL**: https://apify.com/deriverge/google-autocomplete-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** SEO tools, E-commerce
- **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.
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

Google Autocomplete Scraper collects the suggestions Google shows while people type. By default each keyword is also typed with every letter and digit after it, and optionally with question words or prepositions, and the results are merged into one row per phrase with its best position, Google's relevance score and how often it came up. It works in 50 countries, and YouTube, Google Shopping and Bing can be added as sources. Click **Start** to try the prefilled `running shoes`. Suggestions carry no search volume. It costs $0.10 per 1,000 suggestions on the Free plan ($0.05 on Business), and the $5 of monthly credit in Apify's Free plan covers about 50,000 suggestions.

### What data does it return?

| Field | Description |
|---|---|
| `keyword` | The suggested phrase, e.g. `running shoes zero drop`. |
| `seed` | The keyword from your input that led to the phrase. |
| `source` | Where the suggestion came from: `google`, `youtube`, `googleShopping` or `bing`. Rows from before 11 October 2026 can also have `amazon`. |
| `query`, `modifier` | What was typed when the phrase first came up (`running shoes z`) and what was added to the keyword for that query (`z`). `modifier` is `null` for the keyword alone. |
| `position` | The phrase's best place in any list it appeared in, 1 being the top. In September 2026 the lists had up to 15 suggestions on Google, YouTube and Google Shopping, and 12 on Bing. |
| `relevance` | Google's own score for the suggestion, e.g. `1250`, on Google, YouTube and Google Shopping; `null` on Bing. |
| `type` | `QUERY` for ordinary suggestions and `NAVIGATION` for a web address such as `http://kopfhoerer.de` on the Google sources, `null` on Bing. |
| `timesSuggested` | How many of the typed queries returned the phrase. |
| `wordCount`, `containsSeed` | Number of words, and whether every word of the keyword is in the phrase. |
| `isQuestion` | `true` when the phrase starts with a question word or ends with a question mark. |
| `country`, `language`, `checkedAt` | Country and language code used, and when the phrase was collected. |

### How to get Google Autocomplete suggestions

1. Enter **Keywords**, one per line: a product, a topic or a brand name. Each keyword is expanded and counted on its own.
2. Pick the **Sources**. Google Search is selected by default.
3. Choose the **Country** and, if needed, a **Language** such as `de` or `pt-BR`; left empty, the country's main language is used. The country also picks the Bing market.
4. Choose the expansions in **Expand keywords with**. Letters and digits, the default, type the keyword followed by a to z and 0 to 9. Questions put words such as how, what and why in front of it. Prepositions add words such as for, with and vs after it. With all three, an English keyword becomes 65 queries per source.
5. Raise **Maximum rows** from the prefilled 100, click **Start** and export the rows from the **Output** tab. In September 2026, a run of 840 queries took under 30 seconds and returned 5,464 suggestions.

An API input for two keywords in the UK:

```json
{
  "keywords": ["running shoes", "trail running"],
  "sources": ["google", "youtube", "bing"],
  "country": "GB",
  "expansions": ["alphabet", "questions"],
  "maxSuggestionsPerKeyword": 500
}
```

### Example output

One suggestion from a run on 29 September 2026 for `running shoes` on Google in the US, expanded with letters and digits. `running shoes zero drop` first came up when `running shoes z` was typed, and 2 of the 37 queries returned it.

```json
{
  "keyword": "running shoes zero drop",
  "seed": "running shoes",
  "source": "google",
  "country": "US",
  "language": "en",
  "query": "running shoes z",
  "modifier": "z",
  "position": 1,
  "relevance": 1250,
  "type": "QUERY",
  "timesSuggested": 2,
  "wordCount": 4,
  "containsSeed": true,
  "isQuestion": false,
  "checkedAt": "2026-09-29T18:48:07.944Z"
}
```

### How much does it cost to get Google Autocomplete suggestions?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 suggestions | $0.10 | $0.08 | $0.065 | $0.05 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

Collecting 20,000 suggestions costs $2.00 on the Free plan and $1.00 on Business. A phrase is charged once per keyword and source, however many queries return it.

### Limits

- Google adds local suggestions for the place a request comes from. US runs in September 2026 returned `running shoes alexandria va` and `running shoes frederick md`.
- The actor asks without cookies or a signed-in account, so results carry no personal search history.
- The number of suggestions varies a lot by source and keyword. In a September 2026 run in Germany with all expansions, Google gave between 444 and 768 suggestions per keyword.
- Amazon is no longer a source. The robots.txt of Amazon's suggestion service disallows automated access, so since 11 October 2026 an input that still asks for `amazon` gets a warning in the log and no rows from it, and nothing is charged for it. Saved tasks with `amazon` keep running with their other sources.
- Question and preposition words exist for English, German, French, Spanish, Italian, Portuguese, Dutch, Polish and Czech. Other languages get the English words.
- Bing uses the country's market and ignores **Language**.
- A keyword stops expanding once **Maximum suggestions per keyword and source** is reached, 1,000 by default.
- When a search engine limits the requests, the actor waits and slows down. After 3 limits in a row, or a captcha page, it stops asking that search engine for the rest of the run, keeps the suggestions it has and names the search engine in the log and the status message. A query that fails 5 times is skipped, and the run is marked as failed if fewer than half of its queries succeed.

### Watching a brand or topic

Save the input as a task or give it a **Watch name** such as `brand-monitor`, and schedule it weekly. Every run then writes a `CHANGES` record to its key-value store: for each keyword and source whose top 10 changed, the top 10 suggestions for the keyword alone now and in the previous run, and the phrases that entered or left. With **Return only suggestions new since the last run** on, the dataset holds only phrases not yet returned for that keyword and source, and you pay only for those. Phrases that did not fit under **Maximum rows** or the spending limit are returned by the next run. A phrase not seen for 90 days is forgotten and counts as new again.

### FAQ

#### Is it legal to scrape Google Autocomplete?

The actor reads the suggestions that Google, YouTube and Bing show to anyone typing in their search boxes, and it starts at most one query every 120 milliseconds per source. Suggestions are search phrases and do not identify the people who typed them, although a phrase can contain the name of a public person or a company. Check each service's terms before republishing the lists; you are responsible for how you use them.

#### How do I find the strongest keywords?

Rows come sorted within each keyword and source: the most often suggested first, then by best position. A phrase that comes up under many letters is closely tied to the keyword; a phrase seen once is a narrower, long-tail idea. `containsSeed` and `wordCount` separate close variants from loosely related phrases.

#### What happened to the Amazon source?

It was removed on 11 October 2026. Amazon's suggestion service disallows automated access in its robots.txt, and the actor follows robots.txt. A task that still lists `amazon` runs with its other sources and logs a warning; when `amazon` is its only source, the run ends with no rows and no charge.

### Related scrapers

- [Google Trends Trending Now Scraper](https://apify.com/deriverge/google-trends-trending-now-scraper)
- [Google News Scraper](https://apify.com/deriverge/google-news-scraper)
- [Google Ads Transparency Scraper](https://apify.com/deriverge/google-ads-transparency-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

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

# Actor input Schema

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

Seed keywords, one per line, for example "running shoes", "crm software" or a brand name. Each one is expanded and its suggestions are merged.

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

Which autocomplete to read. Pick several to compare what people type on Google, YouTube, Google Shopping and Bing.

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

Country of the searchers. It also picks the Bing market (for example Germany uses de-DE).

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

Language code such as en, de, es or pt-BR. Empty means the main language of the country.

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

Besides the keyword itself, also ask for the keyword followed by each letter and digit, preceded by question words, or followed by prepositions. Question and preposition words are localized for English, German, French, Spanish, Italian, Portuguese, Dutch, Polish and Czech. Leave empty for the keyword alone.

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

Stop expanding a keyword once this many unique suggestions are collected for one source.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only suggestions that were not there before. Schedule it to spot new trends and new searches around your brand.

## `watchName` (type: `string`):

Name of the snapshot, for example "brand-monitor". Also fills the CHANGES record with the changes in the top 10 suggestions for each keyword. Runs from a saved task get one automatically.

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

Hard cap on returned suggestions in the run.

## Actor input object example

```json
{
  "keywords": [
    "running shoes"
  ],
  "sources": [
    "google"
  ],
  "country": "US",
  "expansions": [
    "alphabet"
  ],
  "maxSuggestionsPerKeyword": 1000,
  "newOnly": false,
  "maxItems": 100
}
```

# Actor output Schema

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

One row per unique suggestion, keyword and source, with position, relevance and how often it was suggested.

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

For each keyword and source, suggestions that entered or left the top 10 since the previous run with the same watch name.

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

Keywords, sources, country, suggestions returned and requests.

# 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": [
        "running shoes"
    ],
    "sources": [
        "google"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/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": ["running shoes"],
    "sources": ["google"],
    "maxItems": 100,
}

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

```

## MCP server setup

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