# Autocomplete Keywords · 5 Engines (`steadyfetch/google-keyword-suggest-scraper`) Actor

Never charged for an engine that returns nothing. Autocomplete keywords from Google, YouTube, Amazon, Bing and the App Store in one run. One seed, five engines, no API key and no per-run minimum — and every row says whether it was charged.

- **URL**: https://apify.com/steadyfetch/google-keyword-suggest-scraper.md
- **Developed by:** [Steadyfetch Team](https://apify.com/steadyfetch) (community)
- **Categories:** SEO tools, AI, Agents
- **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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Autocomplete Keywords · 5 Engines

**One seed keyword, five autocomplete engines, one run — and no start fee.** Google,
YouTube, Amazon, Bing and the App Store all answer the same seed, and you are charged
only for the suggestions that actually come back. An engine that has nothing to say for
your seed costs you nothing, and says so in its own row.

No API key. No cookie. No login. No per-run minimum.

*Unofficial. This actor is not affiliated with, endorsed by, or sponsored by Google, YouTube, Amazon, Microsoft (Bing) or Apple. All product names and trademarks belong to their owners and are used here only to describe which public autocomplete endpoints this tool reads.*

Issues answered in about 3 hours.

Every row carries `charged` and `missReason`, so you can reconcile the invoice from the
dataset itself without opening the console. **Only rows with `charged: true` were billed.**

***

### Output

| field | notes |
|---|---|
| `seed` | your own seed keyword, echoed back |
| `engine` | which of the five suggested it |
| `suggestion` | the phrase the engine returned |
| `position` | where it ranked in that engine's answer for that query |
| `expansionToken` | the letter, question word or preposition that produced it — `null` for the bare seed |
| `country` · `language` | the market this answer is for |
| `fetchedAt` | when it was fetched |
| `charged` · `missReason` · `statusReason` | the reconciliation trio |

Plus **one summary row** with `delivered`, `stoppedBy`, `resumeCursor` and `chargedEvents`.

**See real output before you spend anything:** [30 suggestions across all five engines, from a
verified run](https://api.apify.com/v2/datasets/TKGPR1W83z0itbHI5/items?clean=true\&format=json)
— three seeds, a-to-z expansion, every row exactly as this actor delivers it.

***

### Agent / API paste-block

```
Actor:      steadyfetch/google-keyword-suggest-scraper
Required:   seeds          (array of seed keywords; leave the default for uncharged samples)
Optional:   engines        (google | youtube | amazon | bing | appstore — default all five)
            country        (two-letter code, default US)
            language       (two-letter code, default en)
            expansion      (none | alphabet | questions | prepositions | all, default none)
            maxPerSeed     (integer, default 100 — counted PER ENGINE)
            maxItems       (integer, default 1000 — hard cap for the whole run)
            maxRunSeconds  (integer, default 600 — clean stop, never a timeout kill)
Charges:    keyword-suggestion   once per suggestion delivered
Build spec: https://apify.com/steadyfetch/google-keyword-suggest-scraper/api
Token:      https://console.apify.com/settings/integrations
```

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyfetch~google-keyword-suggest-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"seeds":["air fryer"],"country":"US"}'
```

Agents and MCP callers: **omit a field you do not want — do not send `null`.** An explicit
`null` is a type violation the platform rejects before the run is created.

***

### The five engines

| engine | what it tells you | suggestions per query (measured) |
|---|---|---|
| `google` | what people search for on the web | 10 |
| `youtube` | what people search for in video | 14 |
| `amazon` | what shoppers type into a product search | 9 |
| `bing` | a second, independent web index | 20 |
| `appstore` | what people search for in the iOS App Store | 8 |

One seed across all five is around **60 suggestions**. Measured over 50 seeds per engine
on 2026-08-27.

***

### Expansion: one seed into hundreds

| mode | what it asks | extra queries per seed, per engine |
|---|---|---|
| `none` *(default)* | the seed | 0 |
| `alphabet` | `seed a` … `seed z` | 26 |
| `questions` | `how seed`, `what seed`, `why seed` … | 10 |
| `prepositions` | `seed for`, `seed with`, `seed vs` … | 15 |
| `all` | all of the above | 51 |

Expansion multiplies requests, results **and** cost. One seed on `all` across five engines
is about 260 queries and roughly 2,500 suggestions. That is why it is off by default, and
why `maxPerSeed` is counted **per engine** — so Bing cannot eat your cap before the App
Store is asked.

***

### Countries

Google, YouTube and Bing take `country` as a **bias**, not a guarantee: their public
autocomplete endpoints weigh the country parameter alongside where the request comes from,
so a US-flavoured result can appear in a GB run.

Amazon and the App Store are different — they need a real marketplace or storefront id, and
this actor only ships the ones it verified answering live:

- **Amazon:** US CA MX BR GB DE FR IT ES NL SE PL JP AU AE SA SG TR
- **App Store:** 51 storefronts including US GB DE FR IT ES NL SE PL CA AU NZ JP KR CN IN
  BR MX AR CL CO SG MY TH VN ID PH TR SA AE EG IL ZA NG RU UA and the rest of the EU

Ask for a country an engine has no market for and that engine comes back as an uncharged
`MARKET_UNSUPPORTED` row naming the countries it does serve. It is never quietly answered
from the United States instead — a suggestion list for the wrong country looks completely
correct and is completely wrong.

***

### What you are never charged for

| situation | `missReason` | run status |
|---|---|---|
| The engine answered and has no suggestion for your seed | `NO_SUGGESTIONS` | SUCCEEDED — the row shows which engine |
| The engine refused the request (rate limit, challenge) | `ENGINE_BLOCKED` | SUCCEEDED — re-runnable, and the row says so |
| The engine was unavailable or timed out | `ENGINE_UNAVAILABLE` | SUCCEEDED — re-runnable |
| The engine answered in a shape we did not recognise | `ENGINE_CHANGED` | SUCCEEDED — that one is on us |
| That engine has no marketplace/storefront for your country | `MARKET_UNSUPPORTED` | SUCCEEDED — the row names the countries it serves |
| Input we could not read (bad country code, wrong type) | `USER_INPUT` | SUCCEEDED — the row names the fix |
| Your own `maxItems` / `maxRunSeconds` / cost cap | `STOPPED_AT_LIMIT` | SUCCEEDED — summary row + `resumeCursor` |
| A suggestion this run already delivered, after the platform moved or restarted the run | — | SUCCEEDED — the row is never written twice and never charged twice |

**No engine ever disappears.** Every seed-and-engine pair the run planned ends with either
suggestion rows or exactly one row explaining why not — so five engines in, five engines
accounted for.

We never guess. A rate limit is reported as a rate limit, not as "this engine has no
suggestions" — a temporary problem is never dressed up as a permanent verdict.

**This actor may fail when the platform changes things — failed items are never charged.**

***

### What it costs

**from $0.50/1,000 keyword suggestions.** `keyword-suggestion` is the only priced event: one
charge per suggestion delivered. No start fee, no per-run minimum, no separate charge per
engine.

Autocomplete actors on the Apify store, priced on 2026-08-27:

| actor | start fee | per row | 1,000 rows |
|---|---|---|---|
| **this actor** | **none** | **$0.0005** | **$0.50** |
| `memo23/google-suggest-scraper` (Google only) | $0.005 | $0.0005 | $0.505 |
| `automation-lab/google-autocomplete-scraper` (Google only) | $0.00375 | $0.00065 | $0.654 |
| `habit.zhou/keyword-suggest-multi` | $0.005 | $0.00258 | $2.59 |
| `easyapi/all-in-one-autocomplete-keywords-tool` | $0.09 | $0.00299 | $3.08 |

A five-suggestion run costs five suggestions. A run where every engine comes back empty
costs nothing.

***

### Limits are hard limits

`maxItems`, `maxPerSeed` and `maxRunSeconds` stop the run exactly where you set them. The
run still finishes **successfully**, the summary row names which limit bound, and
`resumeCursor` lists the seeds that were not reached — so you continue from there instead
of paying to re-collect what you already have.

***

### FAQ

**How much does 1,000 keyword suggestions cost?**
$0.50 at the lowest tier, and nothing else — no start fee, no per-run minimum, no
per-engine fee. Engines that return nothing are not rows you pay for.

**Is there a Google autocomplete API?**
Not a public, documented one. This actor reads the same public suggestion endpoints your
browser's search box uses — Google, YouTube, Amazon, Bing and the App Store — with no API
key and no login anywhere.

**Why do I get different suggestions than I see in my own browser?**
Autocomplete is personalised and local. These runs carry no cookie and no signed-in
profile, so you get the unpersonalised list for the market you asked for — which is the
one you want for keyword research.

**Can I get questions like "how to..." and "what is..."?**
Set `expansion` to `questions`, or `all` for question words, prepositions and the a-to-z
alphabet soup together.

**Do duplicate suggestions cost twice?**
No. Within one seed and one engine a repeated suggestion is one row, charged once. The
same phrase from two different engines is two rows, because those are two different data
points. That holds across the run's whole life: if the platform moves the run to another
server, restarts it, or you resurrect it, the suggestions already in your dataset are
skipped rather than collected and billed a second time.

**Which engine should I use for product keywords?**
Amazon for what shoppers type, Google and Bing for what searchers type, YouTube for what
viewers type, the App Store for software. Running all five is the point — cross-engine
overlap is the strongest signal a keyword is real.

**Does `{}` cost anything?**
No. With no seeds it returns uncharged sample rows so you can see the exact output shape
before spending anything.

***

### Steadyfetch trends & keyword suite

One actor per surface, one job each, the same contract everywhere: **all-inclusive pay per event,
no start fee, charged only on delivery** — so a workflow built for one of them ports to the next.

| What you want | Actor |
|---|---|
| Interest over time, related queries, regions, compare | [Google Trends · No Charge on Miss](https://apify.com/steadyfetch/google-trends-scraper) |
| What is trending right now, by country | [Google Trends Now · No Start Fee](https://apify.com/steadyfetch/google-trends-now-scraper) |
| Rising and Breakout queries, with the real growth number | **Breakout Keywords from Trends** *(publishing soon — `steadyfetch/breakout-keywords-scraper`)* |
| Autocomplete suggestions across 5 engines | **this actor** |
| Monthly search volume and CPC for a keyword list | **Keyword Volume & CPC · No Minimum** *(publishing soon — `steadyfetch/keyword-search-volume-scraper`)* |
| What is trending on social platforms | [Social Trends · 4 Platforms](https://apify.com/steadyfetch/social-trends-scraper) |

**The rest of the steadyfetch shelf** — same contract everywhere: all-inclusive pay per event,
no start fee, charged only on delivery.

| Family | Actors |
|---|---|
| Ad creative intelligence | [Facebook](https://apify.com/steadyfetch/facebook-ads-transcript-scraper) · [Google Ads video](https://apify.com/steadyfetch/google-ads-video-transcript-scraper) · [TikTok](https://apify.com/steadyfetch/tiktok-ads-transcript-scraper) · [LinkedIn](https://apify.com/steadyfetch/linkedin-ads-transcript-scraper) · [Google Ads text & OCR](https://apify.com/steadyfetch/google-ads-creative-text-scraper) |
| **Trends & keywords** | [Google Trends](https://apify.com/steadyfetch/google-trends-scraper) · [Trends Now](https://apify.com/steadyfetch/google-trends-now-scraper) · Breakout keywords · Autocomplete keywords · Keyword volume & CPC · [Social trends](https://apify.com/steadyfetch/social-trends-scraper) |
| YouTube transcripts | [YouTube videos](https://apify.com/steadyfetch/youtube-transcript-scraper) · [YouTube channels](https://apify.com/steadyfetch/youtube-channel-transcripts) |
| Instagram | [Reel transcripts](https://apify.com/steadyfetch/instagram-reel-transcript-scraper) · Profile posts |
| Jobs | Indeed · Career sites by domain · Glassdoor · Multi-board |
| Amazon | Products · Search · Bestsellers · Sellers |
| Any media file | [Speech to Text](https://apify.com/steadyfetch/media-transcriber) · any link or file |

Unlinked names are publishing shortly on the same account — search **steadyfetch** on Apify Store.

***

### Templates

[github.com/steadyfetch/n8n-templates](https://github.com/steadyfetch/n8n-templates) —
import-validated n8n workflows, no charge.

# Actor input Schema

## `seeds` (type: `array`):

The seed keywords to expand. Leave the default in place to see uncharged sample rows first.

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

Which autocomplete engines to query. Leave empty for all five.

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

Two-letter country code, for example US, GB, DE, IN, AU.

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

Two-letter language code, for example en, es, de, fr, pt.

## `expansion` (type: `string`):

Ask each engine more than once per seed. None: just the seed. Alphabet: seed + a...z. Questions: how/what/why... + seed. Prepositions: seed + for/with/vs...

## `maxPerSeed` (type: `integer`):

Counted separately for each engine, so one talkative engine cannot eat the cap before the others are asked.

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

Hard cap on charged rows across the whole run.

## `maxRunSeconds` (type: `integer`):

The run stops cleanly before this many seconds and reports what is left, instead of being killed by a timeout.

## Actor input object example

```json
{
  "seeds": [
    "project management",
    "air fryer"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon",
    "bing",
    "appstore"
  ],
  "country": "US",
  "language": "en",
  "expansion": "none",
  "maxPerSeed": 100,
  "maxItems": 1000,
  "maxRunSeconds": 600
}
```

# Actor output Schema

## `suggestions` (type: `string`):

One row per suggestion: the seed it came from, the engine that suggested it, its position in that engine's answer, and the expansion token that produced it. Every row carries `charged` and `missReason`, so the invoice reconciles from the dataset itself. Only rows with charged = true were billed.

## `suggestionsOnly` (type: `string`):

The same rows narrowed to seed, engine, suggestion, position and expansion token — the shape you paste into a spreadsheet.

## `summary` (type: `string`):

Suggestions delivered, engines that returned nothing, engines that refused or were unavailable, requests spent, and what stopped the run.

## `errors` (type: `string`):

Present only when an engine refused a request, was unavailable, or answered in an unrecognised shape: the seed, the engine and the reason. These are re-runnable, not permanent.

# 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 = {
    "seeds": [
        "project management",
        "air fryer"
    ],
    "engines": [
        "google",
        "youtube",
        "amazon",
        "bing",
        "appstore"
    ],
    "country": "US",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyfetch/google-keyword-suggest-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 = {
    "seeds": [
        "project management",
        "air fryer",
    ],
    "engines": [
        "google",
        "youtube",
        "amazon",
        "bing",
        "appstore",
    ],
    "country": "US",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("steadyfetch/google-keyword-suggest-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 '{
  "seeds": [
    "project management",
    "air fryer"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon",
    "bing",
    "appstore"
  ],
  "country": "US",
  "language": "en"
}' |
apify call steadyfetch/google-keyword-suggest-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyfetch/google-keyword-suggest-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/GvxnYLascKSHpaQcy/builds/L5ayCA83fj6ddQx84/openapi.json