# Google Autocomplete Keyword Scraper (`mina_safwat/google-autocomplete-keywords-scraper`) Actor

Keyword research tool: turns seed keywords into hundreds of long-tail keyword ideas from Google autocomplete, with A–Z, number, question and preposition expansions, plus YouTube, Google Shopping, Amazon and Bing suggestions, by country and language.

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

## Pricing

$0.30 / 1,000 keywords

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

### What does Google Autocomplete Keyword Scraper do?

**Google Autocomplete Keyword Scraper** is a **keyword research tool** that turns a few seed keywords into **hundreds of long-tail keyword ideas** straight from **Google autocomplete**, the suggestions people see as they type in the search box. It types each seed the way keyword tools do (with **a–z**, **0–9**, **question words** and **prepositions**), can dig **recursively** into the keywords it finds, and can also ask **YouTube, Google Shopping, Amazon and Bing** for their suggestions, for any **country and language**.

Try it with the prefilled seed: open the Actor, click **Start**, and about 50 keyword ideas for "coffee maker" are ready in a few seconds. Because it runs on the Apify platform, you also get API access, scheduled runs, integrations (Google Sheets, Make, Zapier, Slack, webhooks) and run monitoring.

### Why use Google autocomplete for keyword research?

- **Real searches, not guesses.** Autocomplete shows what people actually type into [Google](https://www.google.com), so every idea is a query someone searches for.
- **Long-tail keyword ideas at scale.** One seed with a–z and question words gives about 400–500 unique ideas on Google; recursion finds thousands.
- **Content and FAQ planning.** Question expansions (how, what, why, can, is…) surface the questions your audience asks, ready for blog posts, FAQs and "People also ask"-style sections.
- **Platform-specific ideas.** YouTube suggestions for video topics, Google Shopping and Amazon suggestions for product and e-commerce keywords, Bing for a second search engine's view.
- **Local SEO and international markets.** Pick the country and language to see what people search in Germany, India or Brazil, in their own language.
- **Cheap and fast.** Plain HTTP requests, no browser: thousands of ideas per minute.

### How to find keyword ideas with Google autocomplete

1. Type one or more **seed keywords** into the Input tab, one per line, such as `coffee maker` or `running shoes for women`.
2. Pick the **suggestion sources** (Google web search is on by default).
3. Choose the **expansions**: a–z and question words are on by default; add 0–9 and prepositions for more ideas.
4. Optionally set **recursive depth** to 1 or 2 to also expand the keywords found.
5. Set the **country** and **language**, then click **Start**. Download the keyword ideas when the run finishes.

You can also paste a search results link, such as `https://www.google.com/search?q=cold+brew`, a YouTube, Amazon or Bing search link, with or without `https://`: its search words become the seed.

### Input

Everything is set on the Input tab. In JSON, the input looks like this:

```json
{
    "keywords": ["coffee maker", "cold brew"],
    "sources": ["google", "youtube", "amazon"],
    "addAlphabet": true,
    "addNumbers": false,
    "addQuestions": true,
    "addPrepositions": false,
    "recursiveDepth": 0,
    "maxKeywordsPerSeed": 500,
    "country": "us",
    "language": "en"
}
```

| Field | What it does |
|---|---|
| `keywords` | Seed keywords, one per line. Search results links work too: their search words are used. API callers can also send `{"keyword": "..."}` or `{"url": "..."}` objects. |
| `sources` | Where suggestions come from: `google` (web search, the default), `youtube`, `google-shopping`, `amazon` and `bing`. Each source gives its own rows. |
| `addAlphabet` | Types the seed followed by each letter, `coffee maker a` … `coffee maker z` (26 lookups). Default: on. |
| `addNumbers` | Types the seed followed by each digit, `coffee maker 0` … `coffee maker 9` (10 lookups). Default: off. |
| `addQuestions` | Types how, what, why, when, where, which, who, can, is, are, does and will before the seed (12 lookups). Default: on. |
| `addPrepositions` | Types the seed followed by for, with, without, near, to, vs, versus, like, or and (10 lookups). Default: off. |
| `recursiveDepth` | `0` types the seed and its expansions only. `1` also types every new keyword found; `2` does that once more. Default: 0. |
| `maxKeywordsPerSeed` | Stops after this many unique keywords for each seed on each source. Default: 500. |
| `country` | Two-letter country code such as `us`, `gb`, `de` or `in` (`uk` works too). For Amazon it picks the store. Default: `us`. |
| `language` | Language code such as `en`, `de`, `ar` or `pt-BR`. Default: `en`. |
| `proxyConfiguration` | Leave empty. The services answer the Actor directly; if one refuses, it retries through Apify's datacenter and then residential proxies on its own. |

### Output

Each unique keyword idea becomes one row. Here is a real example from a run with seed "air fryer":

```json
{
    "keyword": "air fryer asparagus",
    "source": "google",
    "position": 1,
    "seed": "air fryer",
    "query": "air fryer a",
    "expansionType": "alphabet",
    "expansion": "a",
    "depth": 0,
    "relevance": 1250,
    "suggestionType": "QUERY",
    "wordCount": 3,
    "country": "US",
    "language": "en",
    "scrapedAt": "2026-10-20T14:19:30+00:00"
}
```

And one from Amazon's German store, where relevance is not published:

```json
{
    "keyword": "makita kaffeemaschine akku 18v",
    "source": "amazon",
    "position": 1,
    "seed": "kaffeemaschine",
    "query": "kaffeemaschine a",
    "expansionType": "alphabet",
    "expansion": "a",
    "depth": 0,
    "relevance": null,
    "suggestionType": null,
    "wordCount": 4,
    "country": "DE",
    "language": "de",
    "scrapedAt": "2026-10-20T14:19:23+00:00"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data fields

| Field | Description |
|---|---|
| `keyword` | The suggested keyword, as the service wrote it (Google and YouTube write in lower case). |
| `source` | `google`, `youtube`, `google-shopping`, `amazon` or `bing`. |
| `position` | Where the suggestion appeared in the list for its query, starting at 1. |
| `seed` | The seed keyword it was found for. |
| `query` | The exact text typed to get it, such as `coffee maker a` or `how coffee maker`. |
| `expansionType` | `seed`, `alphabet`, `number`, `question`, `preposition` or `recursive`. |
| `expansion` | The letter, digit or word added; for `recursive`, the keyword it grew from; `null` for the seed itself. |
| `depth` | 0 for the seed and its expansions, 1 or 2 for recursive levels. |
| `relevance` | Google's own relevance score for the suggestion (higher is stronger, typically 550–1300). Google, YouTube and Google Shopping only; `null` for Amazon and Bing. |
| `suggestionType` | Google's suggestion type, almost always `QUERY`. `null` for Amazon and Bing. |
| `wordCount` | Number of words in the keyword, handy for filtering long-tail ideas. |
| `country` | The country the suggestions are for, such as `US`. |
| `language` | The language asked for, such as `en`. |
| `scrapedAt` | When the row was saved, in UTC. |

**Deduplication:** each keyword is saved once per source across the whole run, including across seeds and expansions, ignoring case. Website suggestions (links such as `https://www.facebook.com/`) are left out, as they are not keywords.

### How much does it cost to find keyword ideas?

The Actor uses **pay-per-event** pricing: you pay per keyword idea saved, and nothing for lookups that return nothing new. See the **Pricing** tab for the exact price.

A default run (one seed, Google, a–z and question words) saves up to 500 keyword ideas in about 5–10 seconds. Seeds that return nothing are never charged, and if you set a maximum cost for a run, the Actor stops as soon as it is reached.

### Tips for keyword research with autocomplete

- **Start broad, then go deep.** Use short seeds (`coffee maker`) with a–z and questions first; turn on recursion when you need thousands of ideas.
- **Questions for content, prepositions for intent.** Question words find FAQ topics; `for`, `with`, `vs` and `near` find use cases, comparisons and local intent.
- **Numbers for products.** `addNumbers` finds model numbers, sizes and years, best combined with Google Shopping or Amazon.
- **Use `maxKeywordsPerSeed` to control cost.** Recursion multiplies lookups quickly; the limit stops each seed as soon as it is reached.
- **Match language to the seed.** Write seeds in the language you set: `kaffeemaschine` with `de`/`de`, not `coffee maker`.
- **Schedule runs** to watch how suggestions change, for example around seasonal events.

### FAQ, disclaimers and support

**Does it give search volume?** No. Autocomplete shows which queries people type, ordered by Google's relevance, but Google does not publish search volumes there. `position` and `relevance` tell you which suggestions Google ranks highest.

**Why are Google Images and Google News not sources?** Their suggestion boxes return the same suggestions as Google web search (checked October 2026), so they would only add duplicate rows. YouTube and Google Shopping do return their own suggestions, and are included.

**Which Amazon stores are supported?** us, ca, mx, br, gb, de, fr, it, es, nl, se, pl, tr, be, eg, ae, sa, in, jp, au and sg. For other countries Amazon is skipped and noted in the `FAILED_INPUTS` record, while the other sources still run.

**Why do some suggestions look odd?** They are what the services suggest. Very rare or made-up seeds can get unrelated suggestions from Google, and Amazon sometimes suggests products that do not start with your seed.

**What happens to seeds that return nothing?** They are not saved as rows, so you are not charged for them. Each one is listed with its reason (no suggestions, every suggestion already saved for an earlier seed, unusable entry, or refused by the service) in the `FAILED_INPUTS` record of the run's key-value store, and the run's status message gives the counts. A run fails only when every seed was refused by the services.

**Is it legal to scrape autocomplete suggestions?** The Actor reads the public suggestion lists that Google, YouTube, Amazon and Bing show to anyone typing in their search boxes. Suggestions are aggregated search queries, not personal data. You are still responsible for making sure your use complies with each service's terms and with the laws that apply to you. If in doubt, ask a lawyer.

**Found a problem or need a custom solution?** Open an issue on the **Issues** tab and we will look into it. Custom keyword research tools and data feeds are available on request.

# Actor input Schema

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

The keywords to find ideas for, one per line, such as coffee maker or running shoes for women. You can also paste a search results link (https://www.google.com/search?q=coffee, a YouTube, Amazon or Bing search link): its search words are used.

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

Where the suggestions come from. Each source is asked separately and gives its own rows, so a keyword found on two sources appears once per source.

## `addAlphabet` (type: `boolean`):

Also types the seed followed by each letter: coffee maker a, coffee maker b … coffee maker z (26 lookups).

## `addNumbers` (type: `boolean`):

Also types the seed followed by each digit: coffee maker 1 … coffee maker 9 (10 lookups). Good for finding sizes, years and models.

## `addQuestions` (type: `boolean`):

Also types question words before the seed: how, what, why, when, where, which, who, can, is, are, does, will (12 lookups). Finds the questions people ask.

## `addPrepositions` (type: `boolean`):

Also types the seed followed by for, with, without, near, to, vs, versus, like, or, and (10 lookups). Finds use cases and comparisons.

## `recursiveDepth` (type: `integer`):

0 types only the seed and its expansions. 1 also types every new keyword found, to find keywords of keywords; 2 does that once more. Each level multiplies the lookups, so keep the per-seed limit below in mind.

## `maxKeywordsPerSeed` (type: `integer`):

Stops after this many unique keywords for each seed on each source. With the default expansions (a–z and question words) one seed gives about 400–500 on Google.

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

Two-letter country code, such as us, gb, de, in or br. Suggestions follow what people search in that country. For Amazon it picks the store; Amazon has stores in us, ca, mx, br, gb, de, fr, it, es, nl, se, pl, tr, be, eg, ae, sa, in, jp, au and sg.

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

Language code, such as en, de, es, fr, ar or pt-BR. Use the language your seeds are written in.

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

Leave this empty: the suggestion services answer the Actor directly, and if one ever refuses, the Actor retries through Apify's datacenter and then residential proxies on its own.

## Actor input object example

```json
{
  "keywords": [
    "coffee maker"
  ],
  "sources": [
    "google"
  ],
  "addAlphabet": true,
  "addNumbers": false,
  "addQuestions": true,
  "addPrepositions": false,
  "recursiveDepth": 0,
  "maxKeywordsPerSeed": 50,
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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": [
        "coffee maker"
    ],
    "maxKeywordsPerSeed": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("mina_safwat/google-autocomplete-keywords-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 maker"],
    "maxKeywordsPerSeed": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("mina_safwat/google-autocomplete-keywords-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 maker"
  ],
  "maxKeywordsPerSeed": 50
}' |
apify call mina_safwat/google-autocomplete-keywords-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mina_safwat/google-autocomplete-keywords-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/vRcAkQZQXw0pxtzq5/builds/CTbDC1dVBSlKWI4eX/openapi.json