# Google Autocomplete Scraper — Keyword Suggestions & Ideas (`aaronoptimus/google-autocomplete-scraper`) Actor

Google Autocomplete scraper and API for keyword research: hundreds of long-tail ideas and questions per seed keyword, in any country, from Web, YouTube and Shopping suggestions, with optional Google Trends scores. Pay per seed plus a small start fee, no platform fees.

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

## Pricing

from $2.00 / 1,000 seed keyword expandeds

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

Turn a few **seed keywords** into **hundreds of long-tail keyword ideas and questions** straight from **Google Autocomplete**, the suggestions Google shows as people type. Pick any **country** and **language**, read Google **Web search**, **YouTube search** or **Google Shopping**, and optionally add a **Google Trends score** to the best ideas so you can see which ones people actually search for, and whether they're rising.

Results come back **deduplicated and ranked per seed** (optionally across seeds too), one row per idea, ready for CSV, Excel, Google Sheets or the API. You pay per seed keyword expanded, only when it returns ideas.

### Why use this Google Autocomplete scraper

- **Hundreds of ideas per seed.** Each seed is sent to Google with letters a–z, question words (how, what, why...), prepositions (for, with, near...) and comparison words (vs, or, alternative), plus any modifiers you add. One seed sends about 55 queries and usually returns several hundred unique ideas.
- **Google Trends scores, built in.** Turn on *Add Google Trends scores* and the top ideas of each seed get a popularity score compared with the seed (100 = as popular as the seed), a *rising / falling / stable* label and a link to check it on Google Trends.
- **Real questions people ask.** Question words go before the seed (`how coffee maker` → `how to clean a coffee maker with vinegar`), and every idea is tagged with its intent: question, comparison, commercial, local or website.
- **Any country, any language.** Google suggests different completions per country. Enter `US, GB, IN, DE` (or one per line) to get each. Question words and prepositions are built in for English, Spanish, German, French, Portuguese, Italian and Dutch.
- **Web, YouTube and Shopping.** YouTube suggestions are what people search for on YouTube; Shopping suggestions lean toward products and deals.
- **Ranked, not just listed.** Google's own top suggestions for the seed come first, in Google's order. Then ideas that came up in several queries, and higher in the list, rank above one-offs. Each row shows Google's relevance score, how many queries suggested it and its best position.
- **Dig deeper.** *Also expand the top ideas* runs a full second-level expansion on the best ideas of each seed.
- **Clean filters.** Keep only questions (or comparisons, commercial or local ideas), keep only ideas containing the seed, drop words or brands you don't want, merge near-duplicate wordings, remove ideas a related seed already returned, cap ideas per seed.
- **Reliable.** Throttled requests are retried on a fresh IP. If Google keeps refusing, all requests move to residential proxies together. Runs stop cleanly before their timeout and list unfinished seeds. You're never charged for seeds Google refused.
- **No platform fees on top.** Compute and proxy costs are included in the prices below.

### What Google Autocomplete data can you scrape?

One row per keyword idea:

| Field | Example | Meaning |
|---|---|---|
| `keyword` | `coffee maker with grinder` | The keyword idea, as Google suggests it |
| `seedKeyword` | `coffee maker` | The seed it came from |
| `rank` | `1` | Rank within its seed (1 = best) |
| `country`, `language`, `source` | `US`, `en`, `web` | Where the suggestion was read |
| `intents` | `["question"]` | question, comparison, commercial, local, navigational |
| `timesSeen` | `3` | How many of the seed's queries suggested it |
| `bestPosition` | `1` | Highest position it appeared at (1–15) |
| `relevance` | `601` | Google's own relevance score for the suggestion |
| `inSeedSuggestions` | `true` | Google suggests it for the plain seed |
| `wordCount`, `containsSeed` | `4`, `true` | Length, and whether every word of the seed is in it |
| `expansionTypes`, `foundVia` | `["seed", "alphabet"]`, `coffee maker` | Which kind of query found it, and the first query |
| `depth`, `parentKeyword` | `2`, `coffee maker with grinder` | Second-level ideas and the idea they came from |
| `variantOf` | `coffee maker camping` | Set when the idea is just another wording (word order, plural, small words) of a better-ranked idea; `null` for main wordings |

With *Add Google Trends scores* on, scored rows also have:

| Field | Example | Meaning |
|---|---|---|
| `trendsInterestVsSeed` | `24.5` | Search interest compared with the seed, in % (100 = same as the seed; can be above 100) |
| `trendsInterest` | `12.3` | Average interest on a 0–100 scale shared by the seed's scored ideas (100 = the busiest week of the most popular idea) |
| `trendsTrend`, `trendsChangePercent` | `rising`, `38.2` | Last quarter of the period vs the first quarter |
| `trendsPeakDate` | `2026-01-04T00:00:00.000Z` | When interest peaked |
| `trendsHasData` | `false` | `false` = too small for Google Trends to measure: under about 1% of the most popular scored idea, or no Trends data at all (not charged) |
| `trendsUrl` | link | The seed and the idea compared on Google Trends |

The run summary (key-value store record `OUTPUT`) lists the first 200 seeds with its number of ideas, queries sent, queries Google didn't answer, and whether it was charged.

### How much does it cost to scrape Google Autocomplete?

| Event | Price |
|---|---|
| Run start | $0.005 |
| Seed keyword expanded (per country and search type) | $0.002 ($2 per 1,000) |
| Google Trends score (optional, per idea with data) | $0.002 |

| Example | Approx. cost |
|---|---|
| 1 seed, US | $0.007 |
| 10 seeds, US | $0.025 |
| 100 seeds in 3 countries | $0.605 |
| 10 seeds with Trends scores for the top 20 ideas each | up to $0.425 |

The price is the same on every Apify plan. Apify's $5 free plan is enough for about 2,400 seed expansions without Trends scores.

- **Free:** seeds with no suggestions, seeds Google refuses after all retries, seeds where Google left more than 20% of the queries unanswered (you still get the ideas, without Trends scores), and Trends scores for ideas too small for Google Trends to measure.
- *Also expand the top ideas* charges one more seed expansion per idea, only when ideas it found make it into your results.
- To cap any run, set Apify's *Maximum cost per run*. The scraper stops cleanly at the limit, and Trends scores are trimmed to fit.

### How to scrape Google Autocomplete

1. Enter your **seed keywords**, one per line (up to 1,000 per run).
2. Pick **countries** (`US`, `GB`...), the **language** and the **search type** (Web, YouTube, Shopping).
3. Optionally change how seeds are expanded, add your own modifiers or filters, or turn on **Google Trends scores**.
4. Click **Start**. Download the ideas as CSV, Excel or JSON, or use the *Trends scores* view for the Trends columns.

#### Example input

```json
{
    "seedKeywords": ["coffee maker", "espresso machine"],
    "countries": ["US", "GB"],
    "language": "en",
    "sources": ["web"],
    "expandNumbers": true,
    "excludeWords": ["walmart", "costco"],
    "addTrendsScore": true,
    "trendsMaxIdeasPerSeed": 20
}
```

#### Example output

```json
{
    "seedKeyword": "coffee maker",
    "keyword": "coffee maker with grinder",
    "rank": 1,
    "country": "US",
    "language": "en",
    "source": "web",
    "relevance": 601,
    "bestPosition": 1,
    "timesSeen": 2,
    "inSeedSuggestions": true,
    "wordCount": 4,
    "containsSeed": true,
    "intents": [],
    "suggestionType": "QUERY",
    "expansionTypes": ["seed", "preposition"],
    "foundVia": "coffee maker",
    "depth": 1,
    "parentKeyword": null,
    "variantOf": null,
    "trendsScored": true,
    "trendsHasData": true,
    "trendsInterest": 9.4,
    "trendsInterestVsSeed": 11.2,
    "trendsTrend": "stable",
    "trendsChangePercent": 4.1,
    "trendsPeakDate": "2025-12-21T00:00:00.000Z",
    "trendsUrl": "https://trends.google.com/trends/explore?q=coffee+maker%2Ccoffee+maker+with+grinder&date=today+12-m&geo=US",
    "scrapedAt": "2026-10-06T12:00:00.000Z"
}
```

(Trends values above are illustrative.)

### Google Autocomplete API: Python, JavaScript, Zapier, Make and AI agents (MCP)

Run it from your code with the [Apify API](https://docs.apify.com/api/v2) or the Apify clients.

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("aaronoptimus/google-autocomplete-scraper").call(run_input={
    "seedKeywords": ["coffee maker"],
    "countries": ["US"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["keyword"], item.get("intent"))
```

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('aaronoptimus/google-autocomplete-scraper').call({
    seedKeywords: ['coffee maker'],
    countries: ['US'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'ideas');
```

It also works with Make, Zapier, n8n, Google Sheets exports, webhooks and schedules, like any Apify Actor.

**AI agents (MCP):** add `https://mcp.apify.com?tools=aaronoptimus/google-autocomplete-scraper` to Claude, Cursor or any MCP client and ask for keyword ideas in plain language.

> **What this tool doesn't do**
>
> - No search volumes. Exact volumes come only from Google Ads (login). The optional Google Trends score is the closest public signal.
> - Fewer ideas outside en, es, de, fr, pt, it, nl: question words and prepositions are built in for those seven languages; others get letters a-z and English question words.
> - Logged-out, non-personalised suggestions for the country you pick, not what your own browser shows.
> - No CAPTCHA solving, no logins.

### Related tools

By the same developer: [Google Trends Scraper](https://apify.com/aaronoptimus/google-trends-scraper) for search interest over time and by region, [PageSpeed Insights Bulk Audit](https://apify.com/aaronoptimus/pagespeed-insights-bulk-audit) for Core Web Vitals on many pages, [Google Analytics 4 Exporter](https://apify.com/aaronoptimus/google-analytics-4-exporter) for your own GA4 reports as flat rows, [Google Ads Transparency Scraper](https://apify.com/aaronoptimus/google-ads-transparency-scraper) for the ads competitors run, [Google News Scraper](https://apify.com/aaronoptimus/google-news-scraper) for headlines by topic and city, [Google Jobs Scraper](https://apify.com/aaronoptimus/google-jobs-scraper) for job listings with salaries, [Google Hotels Scraper](https://apify.com/aaronoptimus/google-hotels-scraper) for hotel prices, [Google Flights Scraper](https://apify.com/aaronoptimus/google-flights-scraper) for airfare and price calendars.

### FAQ

**How many ideas will I get?** Usually several hundred per seed with the default settings, fewer for very niche seeds. Turning on digits, letters before the seed, your own modifiers or a second level adds more.

**Does it give search volume?** No. Exact search volumes come only from Google Ads, which needs a login. The Google Trends score is the closest public signal: it tells you how popular an idea is compared with the seed and whether it's growing.

**Why do some ideas have no Trends score?** Only the top ideas of each seed are scored (20 by default, up to 200), skipping other wordings of an idea that is already scored (`variantOf`). Ideas too small for Google Trends to measure show `trendsHasData: false`, and you aren't charged for them. The ideas are compared with each other (not squeezed next to a much bigger seed), so long-tail ideas get scores whenever Google Trends has data for them.

**Why is `trendsInterestVsSeed` empty?** When every scored idea is under about 1% of the seed's searches, Google Trends rounds the comparison to zero. Compare those ideas with each other using `trendsInterest`.

**Why does `trendsInterestVsSeed` go above 100?** The idea is searched more than the seed itself, which happens when the seed is unusual or very specific.

**Can I get only questions, like AnswerThePublic?** Yes: set *Only these kinds of ideas* to Questions. Question words are built in for seven languages.

**Does it work for Japanese, Russian, Arabic...?** Yes, Google answers in any language. Question words and prepositions are built in for seven Latin-script languages; for others the tool sends letters a–z and English question words, which return fewer ideas. Add your own modifiers in your language to get more.

**Are the intent tags exact?** They're quick rules on the wording (question words, "vs", "best", "near me"...), good for sorting and filtering. Commercial and local tags use English words.

**Why don't the results match what I see in my browser?** Google personalises suggestions from your search history and location. This tool reads logged-out, non-personalised suggestions for the country you pick, which is closer to what most people see.

**Is it legal?** It reads the public suggestions Google shows to anyone, logged out, and returns no personal data. It never logs in or solves CAPTCHAs. As with any tool, check that your use fits your local laws and Google's terms.

### Support

Found a problem or need a field? Open an issue on the Actor's **Issues** tab. If the Actor saves you time, a short review helps others find it. Runs with problems are easiest to fix when you share the run link.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google.

# Changelog

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

# Actor input Schema

## `seedKeywords` (type: `array`):

Keywords to expand, one per line (a line like "coffee maker, espresso machine" counts as two seeds; "1,000 calorie meal" stays one). Each seed is sent to Google Autocomplete with letters, question words and other modifiers, and every distinct suggestion becomes one keyword idea. Up to 1,000 seeds per run.

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

2-letter country codes (US, GB, DE, IN...), one per line or comma-separated. Google suggests different completions per country. Each seed is expanded (and charged) once per country. Up to 50.

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

Language code of the searches, e.g. en, de, es, fr, pt-BR, ja. Question words and prepositions are built in for en, es, de, fr, pt, it and nl; other languages use the English ones (and letters a–z), so they return fewer ideas.

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

Which Google search box to read: Web search, YouTube search or Google Shopping. Pick several to get each. Each seed is expanded (and charged) once per search type.

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

"coffee maker a", "coffee maker b"... (26 queries). The main source of long-tail ideas.

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

"how coffee maker", "why coffee maker"... Finds the questions people ask (great for FAQ and blog topics).

## `expandPrepositions` (type: `boolean`):

"coffee maker for", "coffee maker with", "coffee maker near"...

## `expandComparisons` (type: `boolean`):

"coffee maker vs", "coffee maker or", "coffee maker alternative"... Finds competitor and comparison keywords.

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

"coffee maker 1", "coffee maker 2"... Useful for product sizes, models and years (10 more queries).

## `expandAlphabetPrefix` (type: `boolean`):

"a coffee maker", "b coffee maker"... Finds words that come before your seed (26 more queries).

## `customModifiers` (type: `array`):

Extra words to try, e.g. "review", "price" or "best {seed} for". Without {seed} the word is added after the seed. Up to 100.

## `expandTopIdeas` (type: `integer`):

Run the same full expansion on the best N ideas of each seed to dig deeper. Each one is charged as one more seed expansion, only when ideas it found are in your results. 0 = off.

## `maxIdeasPerSeed` (type: `integer`):

Keep only the best N ideas of each seed (by rank). 0 = keep all. Doesn't change the price.

## `onlyIdeasContainingSeed` (type: `boolean`):

Drops suggestions like "what espresso machine is best" for the seed "coffee maker".

## `excludeWords` (type: `array`):

Words or phrases to drop, e.g. competitor brands or "free". Matched as whole words, ignoring case.

## `onlyIntents` (type: `array`):

Keep only ideas tagged with at least one of these intents, e.g. just questions for an FAQ. Empty = keep all. (Website suggestions also need "Keep website suggestions" on.)

## `dropVariants` (type: `boolean`):

Keep only the best-ranked wording when ideas differ just by word order, a plural or small words ("camping coffee maker" vs "coffee makers for camping"). Off = keep them all, each pointing to its main wording in variantOf.

## `dedupeAcrossSeeds` (type: `boolean`):

With several related seeds, each idea appears only once per country and search type: under the first seed that found it. Doesn't change the price.

## `includeNavigational` (type: `boolean`):

Google sometimes suggests a website address (e.g. https://www.amazon.com/). Off = drop them.

## `addTrendsScore` (type: `boolean`):

Look up the top ideas of each seed on Google Trends: how popular each is compared with the seed (100 = as popular as the seed), on a 0–100 scale shared by the scored ideas, whether it's rising or falling, and a link to check it. Charged per idea that has Trends data; ideas too small for Google Trends to measure are free.

## `trendsMaxIdeasPerSeed` (type: `integer`):

How many of the top ideas of each seed get a Trends score (near-duplicate wordings of an idea already scored are skipped). Caps the Trends cost per seed.

## `trendsTimeRange` (type: `string`):

Period the Trends score and trend direction cover.

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

Apify Proxy spreads requests over many IP addresses so Google doesn't slow them down. The default works for most runs.

## `useResidentialFallback` (type: `boolean`):

If Google keeps refusing requests, all requests switch to Apify residential proxy automatically. No extra cost to you.

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

How many autocomplete requests run at once. Lower it if you see many retries.

## `maxRetries` (type: `integer`):

Each retry uses a fresh IP address.

## Actor input object example

```json
{
  "seedKeywords": [
    "coffee maker"
  ],
  "countries": [
    "US"
  ],
  "language": "en",
  "sources": [
    "web"
  ],
  "expandAlphabet": true,
  "expandQuestions": true,
  "expandPrepositions": true,
  "expandComparisons": true,
  "expandNumbers": false,
  "expandAlphabetPrefix": false,
  "expandTopIdeas": 0,
  "maxIdeasPerSeed": 0,
  "onlyIdeasContainingSeed": false,
  "dropVariants": false,
  "dedupeAcrossSeeds": false,
  "includeNavigational": false,
  "addTrendsScore": false,
  "trendsMaxIdeasPerSeed": 20,
  "trendsTimeRange": "today 12-m",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "useResidentialFallback": true,
  "maxConcurrency": 6,
  "maxRetries": 6
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `runSummary` (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 = {
    "seedKeywords": [
        "coffee maker"
    ],
    "countries": [
        "US"
    ],
    "language": "en",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("aaronoptimus/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 = {
    "seedKeywords": ["coffee maker"],
    "countries": ["US"],
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("aaronoptimus/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 '{
  "seedKeywords": [
    "coffee maker"
  ],
  "countries": [
    "US"
  ],
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call aaronoptimus/google-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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