# Google Autocomplete Scraper: Suggestions, YouTube, Amazon (`fernandosord/google-autocomplete-keywords`) Actor

Keyword research from autocomplete. Enter seed keywords, get search suggestions from Google, YouTube, Google Shopping, Amazon and Bing, with a to z, number, prefix and question expansion plus a second round. One row per unique suggestion, with its query, position and relevance.

- **URL**: https://apify.com/fernandosord/google-autocomplete-keywords.md
- **Developed by:** [Plainsource](https://apify.com/fernandosord) (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.20 / 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

This Actor collects search autocomplete suggestions for keyword research. Give it seed keywords, pick where to ask (Google web search, YouTube, Google Shopping, Amazon, Bing), and it returns one row per unique suggestion with the query that found it, its position, and Google's relevance score where Google publishes one. It reads the public suggest endpoints these sites use for their own search boxes, so there is no login, no API key and no browser. A typical run of a few hundred suggestions finishes in seconds.

- **Five sources:** Google web, YouTube, Google Shopping, Amazon and Bing. Each has its own suggestion list, so the same seed gives different keywords on each.
- **Expansion modes:** the seed alone, the seed plus a to z, the seed plus 0 to 9, a letter before the seed, question words before it (how, what, why, can, is, does, where, which, when, who) and comparison words after it (vs, versus, for, near, with, without, and, or, to, like).
- **Second round:** with depth 2, the best first-round suggestions are sent as queries of their own, which finds longer, more specific phrases.
- **Country and language:** set the Google country and language, the Amazon marketplace (19 countries) and the Bing market.
- **Deduplicated:** every row is a unique suggestion for its seed and source, and `timesSeen` tells you how many different queries returned it.

### What data you get

One item per unique suggestion for each seed keyword and source:

| Field | What it holds |
|---|---|
| `suggestion` | The suggested search phrase |
| `seed` | The seed keyword you entered |
| `source` | google, youtube, shopping, amazon or bing |
| `query` | The exact text sent when this suggestion first appeared, for example the seed plus a letter |
| `expansion` | seed, alphabet, number, prefix letter, question, preposition or second round |
| `position` | Position in the list returned for that query, starting at 1 |
| `relevance` | Google's relevance score for the suggestion (Google, YouTube and Shopping only; higher is more prominent) |
| `type` | QUERY or ENTITY for Google sources, KEYWORD for Amazon, empty for Bing |
| `description` | Short label Google attaches to entity suggestions, empty for most rows |
| `country`, `language` | Codes used for the request |
| `depth` | 1 for the first round, 2 for a suggestion found by expanding a first-round suggestion |
| `timesSeen` | How many queries in the run returned the same suggestion |
| `scrapedAt` | When the data was collected (UTC) |

### How to use it

1. Enter one or more seed keywords, one per line.
2. Choose the sources. Google web search is selected by default.
3. Set the country and language (for example `de` and `de` for German results).
4. Pick expansion modes. "Seed alone" returns about 10 to 15 suggestions per source. Adding a to z or question words returns hundreds.
5. Optionally set depth 2 for a second round, and set "Max suggestions per seed and source" to cap the cost.
6. Run it, then download the dataset as JSON, CSV or Excel, or read it through the API.

Example input:

```json
{
    "keywords": ["web scraping"],
    "sources": ["google"],
    "country": "us",
    "language": "en",
    "expansions": ["seed", "alphabet"],
    "depth": 1,
    "maxSuggestions": 100
}
```

Example output (from a real run, shortened):

```json
[
    {
        "suggestion": "web scraping python",
        "seed": "web scraping",
        "source": "google",
        "query": "web scraping",
        "expansion": "seed",
        "position": 1,
        "relevance": 1250,
        "type": "QUERY",
        "description": null,
        "country": "us",
        "language": "en",
        "depth": 1,
        "timesSeen": 1,
        "scrapedAt": "2026-11-02T07:46:15.745Z"
    },
    {
        "suggestion": "web scraping app",
        "seed": "web scraping",
        "source": "google",
        "query": "web scraping a",
        "expansion": "alphabet",
        "position": 3,
        "relevance": 650,
        "type": "QUERY",
        "description": null,
        "country": "us",
        "language": "en",
        "depth": 1,
        "timesSeen": 1,
        "scrapedAt": "2026-11-02T07:46:15.745Z"
    }
]
```

A run also writes a `SUMMARY` record to the key-value store: suggestions and queries per seed and source, request counts, and any queries that failed with the reason.

### How much does it cost?

The Actor uses pay-per-event pricing:

- **$0.0002 per suggestion** (one unique row in the dataset)
- **$0.0005 per run start** (the standard Actor start fee)

Queries that return nothing, repeats of a suggestion already found, and failed requests are not charged. Example: 1,000 suggestions cost $0.20 plus the $0.0005 start fee, so $0.2005. The default run of 100 suggestions costs about $0.0205. You can also set a maximum cost for a run in the run options, and the Actor stops when it is reached.

### Use cases

- **SEO and content planning:** build a long-tail keyword list for a topic, then group it by the question words and comparison words people type.
- **YouTube topic research:** see what people type into YouTube's search box for a subject before choosing a video title.
- **Amazon and shopping research:** find product phrases shoppers type, by country, for listings and ads.
- **Paid search:** feed the suggestions into a keyword planner as candidate terms.
- **Market and language checks:** compare the same seed across countries and languages to see how search habits differ.

### FAQ

**Does it return search volume?**
No. Autocomplete endpoints publish no volume or CPC. You get the phrases people actually type, ordered the way the source ranks them, plus Google's relevance score. Use it to find candidates, then check volume in a planner.

**Why is there no Google News source?**
Google's news suggest list was identical to the web list in testing, so it would only return duplicate rows. It is left out.

**How many suggestions can I expect?**
Google web, YouTube and Shopping return up to about 15 per query, Amazon 10 and Bing between roughly 10 and 25. Turning on every expansion mode sends 83 queries per seed and source. In one test run, a seed with every mode plus a depth 2 round (103 requests, 5 seconds) returned 1,217 unique Google suggestions.

**Are the question words translated?**
No. The question words and comparison words are English. For other languages, use the a to z modes, or write your own seeds that already contain the question word (for example "wie funktioniert").

**Which Amazon countries work?**
us, ca, mx, br, gb, de, fr, it, es, nl, se, pl, tr, ae, sa, eg, jp, au and sg. If you pick another country, Amazon is skipped and the other sources still run. Amazon India's suggest endpoint returned errors in testing and is not included.

**Do the letter modes work for every script?**
The letters are a to z and digits 0 to 9, which work well for Latin scripts. For Japanese, Arabic or Cyrillic seeds, the seed-alone and question or comparison modes work, but the a to z modes mostly return suggestions with a Latin letter appended.

**What if a source blocks requests?**
The Actor retries with backoff on rate limits. If eight queries in a row fail for a source, it stops using that source for the rest of the run, keeps the other sources, and lists the errors in `SUMMARY`. If nothing could be loaded at all, the run fails with the error. Failed queries are never added to the dataset or billed.

**Is the data accurate?**
Autocomplete is personalized and changes over time. This Actor sends no cookies or sign-in, so you get the generic list for the chosen country and language, which can still differ slightly between runs.

### Other Actors by this developer

- [Google Trends scraper](https://apify.com/fernandosord/google-trends-reliable) for interest over time and related queries
- [Google Trending Now](https://apify.com/fernandosord/google-trending-now) for what is rising in searches today
- [YouTube channel and search scraper](https://apify.com/fernandosord/youtube-channel-search-scraper) for the videos and channels behind a keyword
- [Google Ads Transparency scraper](https://apify.com/fernandosord/google-ads-transparency-scraper) to see who advertises on your keywords
- [Website contact extractor](https://apify.com/fernandosord/website-contact-extractor) for emails and phone numbers from company sites

# Actor input Schema

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

The words to research, one per line. Each seed is sent to every chosen source, plus the expansions you pick below.

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

Where to ask for suggestions. Google web, YouTube and Google Shopping have separate suggestion lists. Amazon follows the country below (20 marketplaces). Bing follows country and language.

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

Two-letter country code, for example us, gb, de, fr, mx, jp. It sets Google's gl value, the Amazon marketplace and the Bing market. Amazon is available for us, ca, mx, br, gb, de, fr, it, es, nl, se, pl, tr, ae, sa, eg, jp, au and sg.

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

Language code for the suggestions, for example en, de, es, pt-BR, ja. It sets Google's hl value and the Bing market. The seed keywords should be written in that language.

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

How to widen each seed. Seed alone sends the keyword as typed. A to z adds one letter after the seed (seed a, seed b). 0 to 9 adds a digit. Letters before sends a letter then the seed (a seed). Question words send how, what, why, can, is, does, where, which, when and who before the seed. Prepositions send vs, versus, for, near, with, without, and, or, to and like after it. Each mode adds queries, so pick what you need.

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

1 sends only the queries above. 2 adds a second round: the best first-round suggestions of each seed and source are sent as queries of their own to find more specific long-tail keywords. Rows from the second round have depth 2. Values above 2 are treated as 2.

## `secondRoundSeeds` (type: `integer`):

Only used with depth 2. How many first-round suggestions per seed and source are sent again as queries, highest relevance first (Google sources) or in list order. Each one is one extra request.

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

Stops querying a seed and source once this many unique suggestions are found. Each unique suggestion is one billed result. 0 means no cap.

## Actor input object example

```json
{
  "keywords": [
    "web scraping"
  ],
  "sources": [
    "google"
  ],
  "country": "us",
  "language": "en",
  "expansions": [
    "seed",
    "alphabet"
  ],
  "depth": 1,
  "secondRoundSeeds": 10,
  "maxSuggestions": 100
}
```

# Actor output Schema

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

One item per unique suggestion for each seed keyword and source.

# 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": [
        "web scraping"
    ],
    "sources": [
        "google"
    ],
    "country": "us",
    "language": "en",
    "expansions": [
        "seed",
        "alphabet"
    ],
    "depth": 1,
    "maxSuggestions": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fernandosord/google-autocomplete-keywords").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": ["web scraping"],
    "sources": ["google"],
    "country": "us",
    "language": "en",
    "expansions": [
        "seed",
        "alphabet",
    ],
    "depth": 1,
    "maxSuggestions": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("fernandosord/google-autocomplete-keywords").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": [
    "web scraping"
  ],
  "sources": [
    "google"
  ],
  "country": "us",
  "language": "en",
  "expansions": [
    "seed",
    "alphabet"
  ],
  "depth": 1,
  "maxSuggestions": 100
}' |
apify call fernandosord/google-autocomplete-keywords --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fernandosord/google-autocomplete-keywords"
        }
    }
}
```

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/tM1O9aiJmTP4hfgZe/builds/Jw9VnEud5Jb6DDVFj/openapi.json
