# Keyword Suggestions API — Google Autocomplete, Bing | $0.5/1k (`glasswing/keyword-suggestions-scraper`) Actor

Keyword ideas from Google, Google Shopping and Bing autocomplete, no API key. Expand seeds with a-z, questions, prepositions or your own modifiers, in any country and language. Rows carry engine, position, type and a question flag; a keywords mode ranks unique ideas. $0.50 per 1,000.

- **URL**: https://apify.com/glasswing/keyword-suggestions-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (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 $0.50 / 1,000 keyword 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

### What does Keyword Suggestions API do?

Keyword Suggestions API collects the **autocomplete suggestions** that Google, Google Shopping and Bing show while someone types a search, and turns them into a clean keyword list you can download as JSON, CSV or Excel. Type one or more seed keywords, and get back every suggestion with its engine, country, language and position. It works as a **Google autocomplete API** and **keyword suggestions API** alternative: no API key, no login, no browser.

Expand each seed the way keyword research tools do, and one seed turns into hundreds of long-tail ideas:

- **Alphabet**: `coffee maker a`, `coffee maker b` ... `coffee maker 9`
- **Questions**: `how coffee maker`, `why coffee maker`, `can coffee maker` ...
- **Prepositions**: `coffee maker for`, `coffee maker with`, `coffee maker vs` ...
- **Your own modifiers**: `best {seed} 2026`, `cheap {seed}` ...

Typical use cases:

- **SEO keyword research**: find the long-tail and question keywords people actually type, per country and language.
- **PPC and Google Shopping**: product-intent suggestions from Google Shopping for ad groups and negative keyword lists.
- **Content planning**: question keywords (`isQuestion`) for FAQ sections, blog posts and "People also ask" style content.
- **Market and brand monitoring**: what Google and Bing suggest next to your brand or product name, tracked on a schedule.
- **AI agents**: a fast, cheap keyword ideas tool with plain inputs and self-describing rows.

Suggestions are what the engines show at the moment of the run, for the country and language you ask for. They change with location and over time.

### Why use this keyword suggestions scraper?

- **Three engines in one run.** Google web search, Google Shopping and Bing, side by side, with the same row format.
- **Every country and language.** Ask for `us`, `gb`, `de`, `in`, `br` ... and `en`, `de`, `es`, `pt-BR` ...; every combination is one set of requests.
- **Long-tail expansion built in.** Alphabet, question words, prepositions and custom modifiers, with duplicates removed per seed and engine.
- **Unique keyword summary.** The `keywords` output mode merges everything into one row per keyword, with how many seeds and engines returned it, most widely suggested first.
- **Fast and cheap.** A seed on one engine takes about a second; 300+ requests finish in well under a minute. $0.50 per 1,000 suggestions.
- **Honest results.** Every row carries a `status` (`ok`, `not_found`, `error`), so an empty answer is never confused with a failure. Only `ok` rows are billed.

### What data can Keyword Suggestions API extract?

One row per suggestion (default `suggestions` output):

| Field | Type | Description |
|---|---|---|
| `query` | string | The seed keyword from your input |
| `suggestion` | string | The suggestion the engine showed |
| `engine` | string | `google`, `google_shopping` or `bing` |
| `position` | integer | 1-based rank in the engine's list for that request |
| `expansion` | string | The exact string sent to the engine (for example `coffee maker b` or `how coffee maker`) |
| `expansionType` | string | `seed`, `alphabet`, `question`, `preposition` or `custom` |
| `country` | string | Country the engine was asked for, e.g. `US` |
| `language` | string | Interface language the engine was asked for, e.g. `en` |
| `type` | string | `query`, `navigational`, `entity` ... when the engine labels it (Google does, Bing does not) |
| `relevance` | number | The engine's own relevance score, when it gives one |
| `isQuestion` | boolean | True when the suggestion starts with a question word (how, what, why, can, is ...) or contains `?` |
| `wordCount` | integer | Number of words in the suggestion |
| `url` | string | The engine's results page for the suggestion |
| `status` | string | `ok`, `not_found` or `error` (see below) |
| `error` | string | Reason when `status` is not `ok` |
| `scrapedAt` | string | ISO 8601 time of extraction |

In the `keywords` output mode each row is one unique keyword across the whole run, with `query` (the first seed that returned it), `suggestion`, `isQuestion`, `wordCount` and:

| Field | Type | Description |
|---|---|---|
| `seeds` | array | Every seed whose requests returned this keyword |
| `engines` | array | Every engine that returned it |
| `seedCount` | integer | Number of seeds that returned it |
| `engineCount` | integer | Number of engines that returned it |
| `timesSeen` | integer | How many requests returned it |
| `bestPosition` | integer | The best (lowest) position it reached |

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | A suggestion (or, in `keywords` mode, a unique keyword). | Yes |
| `not_found` | The engine answered, but had no suggestion for a seed keyword. In `suggestions` mode the row's `url` is the request that was made; in `keywords` mode `query` names the seed. | No |
| `error` | The engine could not be read after retries. `error` says why. | No |

An expansion that returns nothing (`coffee maker q` on a small market) simply adds no rows; only seeds get a `not_found` row. A run where every seed is `not_found` still ends successfully.

### How to use the Google autocomplete keyword tool

1. Open the Actor in Apify Console and click **Try for free**.
2. Type your seed keywords into **Seed keywords**, one per line.
3. Pick the **Engines**, and optionally **Expand each seed** with the alphabet, questions or prepositions.
4. Set **Countries** and **Languages** (default `us` / `en`).
5. Click **Start**. The default input finishes in a few seconds.
6. Open the **Output** tab, switch between the **Suggestions** and **Unique keywords** views, or **Export** as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl examples), add a **Schedule**, or call it from an AI agent through the Apify MCP server.

### How much does it cost to get keyword suggestions?

Pay-per-event pricing; Apify platform usage (compute) is included, so you pay only these events:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Keyword suggestion (`status: ok` row) | $0.0005 per row ($0.50 per 1,000) |

Examples:

- One seed on Google, no expansion: about 15 suggestions = $0.005 + 15 x $0.0005 = **$0.0125**.
- One seed on Google, Google Shopping and Bing with **alphabet** expansion: 111 requests, 1,361 suggestions after duplicates are removed (measured for `coffee maker`, 9 s on the platform) = **$0.69**.
- 1,000 suggestions of any kind: **$0.505** including the start fee.

In `keywords` mode you pay per unique keyword, not per suggestion row: the same `coffee maker` alphabet run gave 930 unique keywords instead of 1,361 rows (32% fewer, **$0.47**). Rows with `not_found` or `error` are free. Cap spending with **Maximum rows** and the run's **Max total charge**.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["coffee maker"]` | Seed keywords, one per line |
| `engines` | array | `["google"]` | Any of `google`, `google_shopping`, `bing` |
| `expand` | array | `[]` | Any of `alphabet` (+36 requests per seed), `questions` (+10), `prepositions` (+8) |
| `customModifiers` | array | `[]` | Your own words; `best` sends `seed best`, `best {seed} 2026` places the seed yourself |
| `country` | array | `["us"]` | Two-letter country codes |
| `language` | array | `["en"]` | Language codes such as `en`, `de`, `pt-BR` |
| `outputMode` | string | `suggestions` | `suggestions` (one row per suggestion) or `keywords` (unique keywords with counts) |
| `maxSuggestionsPerQuery` | integer | `20` | Keep at most this many suggestions per request |
| `dedupe` | boolean | `true` | Write each suggestion once per seed, engine, country and language |
| `maxItems` | integer | `1000` | Stop after this many rows |
| `startUrls` | array | example | Advanced: Google or Bing search URLs (`...google.com/search?q=...&gl=de&hl=de`); each becomes a seed on that engine and market |
| `proxyConfiguration` | object | off | Optional; not needed from Apify's datacenter |

The number of requests is seeds x engines x countries x languages x (1 + expansions). A single `query` string is also accepted, for callers that send one keyword.

Example input:

```json
{
    "queries": ["coffee maker", "espresso machine"],
    "engines": ["google", "google_shopping", "bing"],
    "expand": ["questions", "prepositions"],
    "country": ["us", "gb"],
    "language": ["en"],
    "maxItems": 2000
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Real rows from a run on the Apify platform (default output):

```json
[
    {
        "query": "coffee maker",
        "suggestion": "coffee maker with grinder",
        "engine": "google",
        "position": 1,
        "expansion": "coffee maker",
        "expansionType": "seed",
        "country": "US",
        "language": "en",
        "type": "query",
        "relevance": 601,
        "isQuestion": false,
        "wordCount": 4,
        "url": "https://www.google.com/search?q=coffee%20maker%20with%20grinder&hl=en&gl=us",
        "status": "ok",
        "scrapedAt": "2026-09-30T16:06:00.191Z"
    },
    {
        "query": "coffee maker",
        "suggestion": "coffee maker with k cup",
        "engine": "google_shopping",
        "position": 3,
        "expansion": "coffee maker w",
        "expansionType": "alphabet",
        "country": "US",
        "language": "en",
        "type": "query",
        "relevance": 601,
        "isQuestion": false,
        "wordCount": 5,
        "url": "https://www.google.com/search?q=coffee%20maker%20with%20k%20cup&tbm=shop&hl=en&gl=us",
        "status": "ok",
        "scrapedAt": "2026-09-30T16:06:05.345Z"
    },
    {
        "query": "coffee maker",
        "suggestion": "coffee maker amazon",
        "engine": "bing",
        "position": 1,
        "expansion": "coffee maker a",
        "expansionType": "alphabet",
        "country": "US",
        "language": "en",
        "relevance": 1300,
        "isQuestion": false,
        "wordCount": 3,
        "url": "https://www.bing.com/search?q=coffee%20maker%20amazon&setmkt=en-US",
        "status": "ok",
        "scrapedAt": "2026-09-30T16:06:00.223Z"
    }
]
```

### Tips

- Start with one seed and one engine to see the output, then add expansions: `alphabet` gives the most ideas, `questions` the best content topics.
- Use the `keywords` output mode when you want one clean, ranked list instead of every suggestion per request.
- Several seeds, countries and engines in one run cost one start fee.
- Sort by `position` for what the engine ranks first; filter `isQuestion` for FAQ content.

### Limitations

- Suggestions are what the engines show publicly to a logged-out visitor in the chosen country and language; they are not search volumes, and they change over time.
- Google, Google Shopping and Bing only. YouTube, Amazon, eBay, Yahoo, DuckDuckGo and Wikipedia are not included: their terms forbid automated collection or resale of their data.
- Bing ignores the language for markets it does not support, and falls back to its default for that country.
- Google sometimes answers nonsense input with keyboard-pattern suggestions instead of an empty list; those are returned as the engine shows them.
- The run is capped at 20,000 requests; split very large seed lists over several runs.

### FAQ

#### Does Google have an autocomplete API?

Google does not sell an autocomplete or keyword suggestions API. This Actor reads the same public suggest endpoints the search boxes use, one small request per keyword, and returns the answers as structured data.

#### Is it legal to collect keyword suggestions?

Search suggestions are public, non-personal text shown to every visitor. You are responsible for how you use the output and for complying with the engines' terms. Read the legal notice below.

#### Can I use this Actor from an AI agent or MCP client?

Yes. Call it with no input for a quick example, or with `{"queries": ["your keyword"]}`. Inputs are plain strings, and every row says what it is (`status`, `engine`, `query`, `expansion`).

#### Why did I get fewer rows than `maxItems`?

Each request returns at most 10-20 suggestions, and duplicates are removed per seed and engine. Add expansions or engines for more ideas.

#### Why do suggestions differ from what I see in my browser?

Suggestions depend on country, language, time and (in your browser) your own search history. This Actor asks as a logged-out visitor in the country and language you choose.

### Related Actors

- [Google Trends Scraper](https://apify.com/glasswing/google-trends-scraper): interest over time, by region and related queries for your keywords.
- [Google News Scraper](https://apify.com/glasswing/google-news-scraper): news articles for any keyword, country and language.

### Legal and data-protection notice

This Actor collects only search suggestions that the engines show publicly to logged-out visitors; it does not extract private user data such as e-mail addresses, phone numbers or precise location, and it does not log in or get around access controls. Suggestions can occasionally contain names of public figures. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not process personal data unless you have a legitimate reason to do so. You are responsible for complying with the engines' terms of service and applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google, Microsoft (Bing) or any other search engine. All trademarks belong to their respective owners.

# Changelog

This Actor's version history is a separate document: https://apify.com/glasswing/keyword-suggestions-scraper/changelog.md

# Actor input Schema

## `queries` (type: `array`):

Keywords to get suggestions for, one per line (for example `coffee maker`, `running shoes`). Each seed is sent to every selected engine, country and language.

## `engines` (type: `array`):

Where to read suggestions from. `google` = Google web search, `google_shopping` = Google Shopping (product intent), `bing` = Bing web search.

## `expand` (type: `array`):

Extra requests per seed for long-tail ideas. `alphabet` sends the seed + a..z and 0..9 (36 extra requests), `questions` sends who/what/when/where/why/how/which/can/are/is + seed (10), `prepositions` sends the seed + for/with/without/near/vs/versus/to/like (8). The seed on its own is always sent.

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

Your own words to combine with every seed, one per line. `best` sends `coffee maker best`; use `{seed}` to place the seed yourself, e.g. `best {seed} 2026` or `cheap {seed}`.

## `country` (type: `array`):

Two-letter country codes to ask the engines for, e.g. `us`, `gb`, `de`, `in`. Suggestions differ by country. Every seed is requested once per country and language.

## `language` (type: `array`):

Interface language codes, e.g. `en`, `de`, `es`, `fr`, `pt-BR`. Google uses it as its `hl` language; Bing combines it with the country into a market such as `de-DE`.

## `outputMode` (type: `string`):

`suggestions` = one row per suggestion per request (seed, expansion, engine, position). `keywords` = one row per unique keyword across the whole run, with how many seeds and engines returned it, most widely suggested first.

## `maxSuggestionsPerQuery` (type: `integer`):

Keep at most this many suggestions from each request (Google returns up to 15, Bing up to 12).

## `dedupe` (type: `boolean`):

In `suggestions` output, write a suggestion only once per seed, engine, country and language, even when several expansions return it.

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

Stop after this many rows. Each saved row with status `ok` is one billable result. One seed without expansion gives about 10-15 rows per engine; with `alphabet` about 200-400.

## `startUrls` (type: `array`):

Optional. Google or Bing search URLs (`https://www.google.com/search?q=...&gl=de&hl=de`, `https://www.bing.com/search?q=...`) or their suggest-endpoint URLs. Each one becomes a seed on that engine, country and language. Leave the example as is when you use Seed keywords.

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

Optional. The Actor works from Apify's datacenter without a proxy. Enable Apify Proxy (datacenter group) only if you see blocked requests; residential proxies are not needed.

## Actor input object example

```json
{
  "queries": [
    "coffee maker"
  ],
  "engines": [
    "google"
  ],
  "expand": [],
  "customModifiers": [],
  "country": [
    "us"
  ],
  "language": [
    "en"
  ],
  "outputMode": "suggestions",
  "maxSuggestionsPerQuery": 20,
  "dedupe": true,
  "maxItems": 1000,
  "startUrls": [
    "https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=coffee%20maker"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "queries": [
        "coffee maker"
    ],
    "engines": [
        "google"
    ],
    "country": [
        "us"
    ],
    "language": [
        "en"
    ],
    "maxItems": 1000,
    "startUrls": [
        "https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=coffee%20maker"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/keyword-suggestions-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 = {
    "queries": ["coffee maker"],
    "engines": ["google"],
    "country": ["us"],
    "language": ["en"],
    "maxItems": 1000,
    "startUrls": ["https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=coffee%20maker"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/keyword-suggestions-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 '{
  "queries": [
    "coffee maker"
  ],
  "engines": [
    "google"
  ],
  "country": [
    "us"
  ],
  "language": [
    "en"
  ],
  "maxItems": 1000,
  "startUrls": [
    "https://suggestqueries.google.com/complete/search?client=chrome&hl=en&gl=us&ie=UTF-8&oe=UTF-8&q=coffee%20maker"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

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