# Google Autocomplete Scraper — Keyword Ideas, YouTube & Bing (`tortuga/google-autocomplete-scraper`) Actor

Keyword ideas from autocomplete: Google, YouTube, Google Shopping, Bing, DuckDuckGo and eBay suggestions for seed keywords, with A-Z, 0-9, question and recursive expansion per country.

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

## Pricing

$0.70 / 1,000 suggestion scrapeds

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 — Keyword Ideas, YouTube & Bing

Turn a few seed keywords into hundreds of long-tail keyword ideas from **autocomplete**: what people start typing in
**Google Search, YouTube, Google Shopping, Bing, DuckDuckGo and eBay**. The actor queries each engine's suggest box for
the seed, the seed + a–z, the seed + 0–9, question words (how, what, why, can, is, best ...) and modifiers (vs, near
me, for, with ...), optionally goes several levels deep, and saves one row per suggestion with its engine, position,
the query that produced it, country and language. Use it for SEO content plans, PPC keyword and negative-keyword
lists, YouTube video ideas, product naming and marketplace listings.

It uses the engines' public suggest endpoints: no browser, no login, no API key. Runs are fast (about 150 queries and
2,000 suggestions in 40 seconds) and you pay only for the suggestions you get.

### What data does it extract?

| Field | Description |
|---|---|
| `keyword` | The autocomplete suggestion, e.g. `air fryer chicken breast` |
| `source` | Engine: `google`, `youtube`, `googleShopping`, `bing`, `duckduckgo` or `ebay` |
| `seed` | Your seed keyword that led to this suggestion |
| `position` | Position of the suggestion in the engine's list for that query (1 = top) |
| `query` | The exact text typed into the engine, e.g. `air fryer c` |
| `expansion` | How the query was built: `seed`, `letter`, `number`, `question`, `modifier` or `recursive` |
| `modifier` | The letter, digit or word added (`c`, `2`, `how`, `vs`), else null |
| `modifierPosition` | `after` or `before` the seed |
| `depth` | 1 for suggestions of the seed and its expansions, 2+ for recursive levels |
| `country`, `language` | Market and interface language used for the query |
| `relevance` | Google's own relevance score (Google, YouTube, Shopping), e.g. 1250, 601 |
| `suggestionType`, `suggestionSubtypes` | Google's suggestion type (`QUERY`, ...) and internal subtype codes |
| `ebayCategories` | eBay category matches for the suggestion, when eBay shows them (`[{id, name}]`) |
| `wordCount` | Number of words, handy for filtering long-tail keywords |
| `suggestionId` | `source|country|keyword`, unique per run |
| `scrapedAt` | UTC timestamp |

With monitoring on, rows also carry `changeType` (`new`).

### How to scrape Google autocomplete suggestions

1. Enter one or more **Seed keywords**, e.g. `air fryer`, `learn python`.
2. Pick the **Engines** (Google Search, YouTube, Bing, Google Shopping, DuckDuckGo, eBay).
3. Choose expansions: **A-Z** (on by default), **0-9**, **Questions & modifiers**, and the **Recursive depth**.
4. Choose one or more **Countries** (and optionally a language), set **Max suggestions**, and click **Start**.

Each suggestion is saved once per engine and country, even if several queries or seeds return it.

### Input example

```json
{
  "keywords": ["air fryer"],
  "sources": ["google", "youtube", "bing"],
  "expandLetters": true,
  "expandQuestions": true,
  "depth": 1,
  "countries": ["us"],
  "maxItems": 1000
}
```

### Output example

```json
{
  "keyword": "air fryer chicken breast",
  "seed": "air fryer",
  "source": "youtube",
  "position": 3,
  "query": "air fryer c",
  "expansion": "letter",
  "modifier": "c",
  "modifierPosition": "after",
  "depth": 1,
  "country": "us",
  "language": "en",
  "relevance": 1050,
  "suggestionType": "QUERY",
  "suggestionSubtypes": [512, 433],
  "ebayCategories": null,
  "wordCount": 4,
  "suggestionId": "youtube|us|air fryer chicken breast",
  "scrapedAt": "2026-10-11T22:33:00Z"
}
```

### How many keyword ideas do I get per seed?

Engines return 7-25 suggestions per query (Google, YouTube and Shopping 15, Bing up to 25, eBay 10, DuckDuckGo 7-8).
Per seed and engine, roughly:

| Expansion | Queries | Suggestions (after removing duplicates) |
|---|---|---|
| Seed only | 1 | 7-25 |
| A-Z | 27 | 200-550 |
| A-Z + 0-9 | 37 | 280-700 |
| Questions & modifiers | +24 | +150-350 on Google/YouTube, +10-50 on Bing, DuckDuckGo, eBay |
| Recursive depth 2 | +1 per suggestion found | about 10x more |

A real run with `air fryer`, A-Z and all six engines returned 2,000 suggestions (the Max suggestions cap) from
155 queries: Bing 544, YouTube 389, Google Shopping 378, Google 350, eBay 209, DuckDuckGo 130.

### How much does it cost?

Pay per result: **$0.0007 per suggestion** ($0.70 per 1,000), plus Apify platform usage of about $0.006 per 1,000
suggestions (datacenter proxy, compute and storage). No start fee, no subscription. Examples: one seed on Google with
A-Z (~350 suggestions) costs about $0.25; one seed on all six engines with A-Z (~2,000) about $1.41. Duplicates within
a run are removed before saving, so they are never charged. Set **Max suggestions** to cap the cost.

### How to get YouTube, Bing, eBay and Google Shopping autocomplete keywords

Select the engines in **Engines**. YouTube suggestions show what people search for on YouTube (great for video titles
and tags), Google Shopping and eBay show buyer and product phrases, Bing and DuckDuckGo give a second opinion on
web searches. Every row says which engine it came from, so you can compare them or filter in a spreadsheet.

### Does it work for other countries and languages?

Yes. Pick one or more **Countries**: the actor sets Google's country (`gl`) and language (`hl`), Bing's market
(`de-DE`), DuckDuckGo's region (`uk-en`) and eBay's site (ebay.de, ebay.co.uk ...). Leave **Language** empty to use
each country's main language, or set it (e.g. `fr` for French in Switzerland). Question words are localized for
German, French, Spanish, Italian, Portuguese and Dutch. eBay has no site for Brazil, India, Japan, Mexico, New Zealand
or Sweden, so eBay is skipped there.

### How does recursive expansion work?

With **Recursive depth** 2, every suggestion found at depth 1 is typed into the same engine again and its own
suggestions are saved with `depth: 2` (3 and 4 go further). Each keyword is queried only once per engine and country,
and every suggestion is saved only once. Each level multiplies the number of queries by about ten, so use **Max
suggestions** to cap the run.

### Does it need a login, an API key or a browser?

No. It uses the same public suggest endpoints the search boxes use, through Apify's datacenter proxy with a fresh IP
for every retry. If the datacenter IPs keep getting blocked, it switches to Apify's residential proxy for the rest of
the run (if your plan includes it).

### Monitor changes on a schedule

Turn on **Only new or changed items** and save the input as a task with a Schedule (e.g. daily): each run outputs
only suggestions (engine + country + keyword) that earlier runs of this watch did not return, with `changeType: "new"`,
so you see new trending searches for your seeds or brand as they appear. Suggestions seen before are not output and
not charged. Every run sends all queries of your settings; **Max suggestions** caps the new rows per run. Use
**Monitoring key** to keep several schedules on the same keywords separate. Engines rotate some suggestions and
localize a few by the IP's location, so a handful of "new" rows per run is normal.

### Why do results differ between runs?

Autocomplete is live: engines update suggestions all the time, personalize some by location (e.g. "coffee shops nyc")
and test variants. Two runs a few minutes apart usually agree on most suggestions but not all.

### Is it legal to scrape autocomplete suggestions?

The actor collects the public search suggestions every visitor sees in the search box; it does not log in or access
anything private. Suggestions sometimes contain names of public figures, brands or places, exactly as the engines show
them. You are responsible for how you use the data and for complying with the engines' terms and applicable law.

### Integrations and API

Use the results in Google Sheets, Zapier, Make, n8n, or call the actor from Python/Node with the Apify client. See
the **API** tab for ready-made snippets.

### Support

Found a bug or need another engine? Open an issue in the **Issues** tab; it is usually answered within a day.

# Actor input Schema

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

Keywords to expand, as you would start typing them in the search box, e.g. "running shoes", "how to learn python", "coffee grinder". Each one is sent to every selected engine.

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

Where to collect autocomplete suggestions: Google Search, YouTube, Google Shopping, Bing, DuckDuckGo, eBay. Each engine gives its own rows (source field).

## `expandLetters` (type: `boolean`):

Also query the seed followed by each letter a-z ("running shoes a", "running shoes b", ...). This is how most long-tail ideas are found: about 27 queries and up to ~350 suggestions per seed and engine.

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

Also query the seed followed by each digit 0-9 ("running shoes 2", ...): finds sizes, years, models.

## `letterPosition` (type: `string`):

Put the A-Z / 0-9 characters after the seed ("running shoes a"), before it ("a running shoes") or both (twice the queries).

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

Also query question words before the seed (how, what, why, when, where, who, which, can, is, are, does, will, should, best) and modifiers after it (vs, near me, for, with, without, or, and, like, to, is). German, French, Spanish, Italian, Portuguese and Dutch use their own words.

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

1 = suggestions for the seed and its expansions. 2 = each suggestion found is queried again for its own suggestions; 3-4 go deeper. Every level multiplies the queries (about 10x), so cap the run with Max suggestions.

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

Country markets to collect suggestions for (Google gl, Bing market, DuckDuckGo region, eBay site). Each country is a separate set of rows. eBay has no site for Brazil, India, Japan, Mexico, New Zealand or Sweden; those are skipped for eBay.

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

Interface language code such as en, de, fr, es, pt, ja. Leave empty to use each country's main language (de for Germany, ja for Japan, en for the US, ...).

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

Stop after this many suggestion rows in total (you pay per row). Each suggestion appears once per engine and country, even if several seeds or queries return it.

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this search returned and output only new items or items whose price/status changed. Use with a Schedule; unchanged items are not charged. Here: only suggestions (engine + country + keyword) that earlier runs of this watch did not return. Every run checks all queries of your settings; Max suggestions caps the new rows output.

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input

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

The suggest endpoints answer Apify's datacenter proxy (the default, cheapest option). Every retry uses a new IP. If the datacenter IPs keep getting blocked, the run switches to RESIDENTIAL once (if your plan has it).

## Actor input object example

```json
{
  "keywords": [
    "running shoes"
  ],
  "sources": [
    "google",
    "youtube",
    "bing"
  ],
  "expandLetters": true,
  "expandNumbers": false,
  "letterPosition": "after",
  "expandQuestions": false,
  "depth": 1,
  "countries": [
    "us"
  ],
  "maxItems": 500,
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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": [
        "running shoes"
    ],
    "sources": [
        "google",
        "youtube",
        "bing"
    ],
    "countries": [
        "us"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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",
        "youtube",
        "bing",
    ],
    "countries": ["us"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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