**More from this account:** [YouTube Transcript Suite](https://apify.com/vonsensey/youtube-transcript-scraper) · [Website Contact & Email Suite](https://apify.com/vonsensey/website-contact-email-extractor) · [Career Site & ATS Jobs Suite](https://apify.com/vonsensey/career-page-job-postings-scraper-api) · [Google News Suite](https://apify.com/vonsensey/google-news-scraper-api) · [Shopify Store Intelligence Suite](https://apify.com/vonsensey/shopify-store-leads-scraper) · [eBay Data Suite](https://apify.com/vonsensey/ebay-scraper-api) · [Amazon Reviews Suite](https://apify.com/vonsensey/amazon-reviews-scraper-api) · [Reddit](https://apify.com/vonsensey/reddit-scraper-posts-comments-api) · [Meta Ad Library](https://apify.com/vonsensey/facebook-ads-library-scraper-meta-ad-api) · [Vinted](https://apify.com/vonsensey/vinted-scraper-api)
**Turn one seed word into thousands of real keyword ideas.** This actor takes a term like
`coffee maker` and fans it out across the alphabet, question words, comparisons and
prepositions on **Google plus 10 more search engines** — then hands back a deduplicated,
filterable keyword list as JSON, CSV or Excel.
**Measured on one seed:** 1,233 unique keywords from Google alone, **3,024 across all 11
engines**, in under 7 seconds.
**You pay per keyword. Duplicates are free, failed lookups are free, and a run that finds
nothing costs nothing.** No actor-start fee.
***
### Why this exists
Most keyword scrapers send your seed to Google once and hand back the ten suggestions the
box happens to show. That is not keyword research — that is one lookup.
Real keyword discovery means asking the engine many different questions:
- what comes after `coffee maker a`, `coffee maker b`, … `coffee maker z`
- what comes after `a coffee maker`, `b coffee maker`, …
- what people actually ask: `how coffee maker`, `why coffee maker`, `can coffee maker`
- what they compare: `coffee maker vs`, `coffee maker alternative`, `coffee maker best`
- what they qualify: `coffee maker for`, `coffee maker with`, `coffee maker without`
That is **101 different questions per seed on one engine**, and each one returns a different
answer. Run it across 11 engines and you have the long tail, not the head.
### What you get
| | |
|---|---|
| **11 search engines** | Google Web, YouTube, Google Images, Google News, Google Shopping, Bing, DuckDuckGo, Amazon, eBay, Wikipedia, Yandex |
| **7 expansion modes** | seed, A-Z suffix, A-Z prefix, questions, comparisons, prepositions, numbers |
| **Google's own relevance score** | the ordering signal Google returns with each suggestion — on 100% of Google rows |
| **Real locale targeting** | `country` + `language` sent on every request, so `de-DE` genuinely returns German keywords |
| **Deduplicated once, globally** | the same keyword found by five prefixes and three engines is one row and one charge, attributed to the first engine that returned it |
| **Built-in filters** | questions only, long-tail only, minimum word count, exclude terms, must-contain-seed |
| **One price, one event** | no actor-start fee, no add-on events, no platform surcharge |
#### Every engine earns its place
Measured unique contribution over Google alone, one seed, all expansions:
| Engine | Keywords | New vs Google | Unique |
|---|---:|---:|---:|
| Google Web | 1,225 | — | — |
| Google News | 850 | 87 | 10% |
| Google Images | 820 | 257 | 31% |
| Bing | 645 | 395 | **61%** |
| YouTube | 579 | 423 | **73%** |
| Amazon | 504 | 317 | **63%** |
| Google Shopping | 492 | 239 | 49% |
| DuckDuckGo | 414 | 204 | 49% |
| eBay | 346 | 276 | **80%** |
| Yandex | 42 | 40 | 95% |
| Wikipedia | 19 | 19 | 100% |
**Union of all 11: 3,024 unique keywords from a single seed — 2.5× what Google alone gives.**
Reaching that in one run means raising both ceilings: `maxKeywords` defaults to 200 and
`maxCostUsd` to $5.00, and the run stops at whichever binds first.
Two honest caveats, because a listing that overclaims is worse than a short one:
**Wikipedia returns few keywords** (19) — it indexes article titles, not search queries, so
its value is entity discovery. **Yandex is thin on English seeds** (42) and much denser on
Russian ones. Both are shipped because ~100% of what they return is unique.
### No fake search volume
Plenty of keyword tools show a "volume" or "popularity" number. Genuine search volume comes
from Google Ads Keyword Planner or a paid clickstream feed — and if a tool has neither, that
number is invented.
**This actor returns no search volume and no CPC.** What it does return is real: the
`relevance` field is **Google's own suggestion-relevance score**, the signal Google itself
uses to order the suggestion list, passed through untouched and labelled as exactly that. Where a
field is unknown it is `null`, never a guess — an invented number silently corrupts whatever
you filter on.
If you need true volume and CPC, pair this with a Keyword Planner tool. This one is the idea
engine.
### Quick start
Paste a seed, press **Start**. That is the whole setup.
```json
{
"seeds": ["coffee maker"],
"sources": ["google"],
"expansions": ["seed", "questions", "alphabet"],
"country": "US",
"language": "en",
"maxKeywords": 200
}
```
Go wide — every engine, every expansion:
```json
{
"seeds": ["coffee maker", "espresso machine"],
"sources": ["google", "youtube", "amazon", "ebay", "bing", "duckduckgo",
"google-shopping", "google-images", "google-news", "wikipedia", "yandex"],
"expansions": ["seed", "questions", "comparisons", "prepositions",
"numbers", "alphabet", "alphabet-prefix"],
"maxKeywords": 5000,
"maxCostUsd": 12
}
```
Mine only the questions — the ones that map straight to FAQ blocks and blog headings:
```json
{
"seeds": ["coffee maker"],
"expansions": ["questions"],
"onlyQuestions": true,
"sources": ["google", "youtube", "bing"]
}
```
Find what shoppers type, for product listings and PPC:
```json
{
"seeds": ["coffee maker"],
"sources": ["amazon", "ebay", "google-shopping"],
"expansions": ["seed", "alphabet", "comparisons"],
"onlyLongTail": true
}
```
### Output
One row per unique keyword:
```json
{
"type": "keyword",
"keyword": "can coffee makers make you sick",
"seed": "coffee maker",
"source": "google",
"sourceLabel": "Google Web Search",
"expansion": "questions",
"modifier": "can",
"rank": 2,
"relevance": 1251,
"suggestType": "QUERY",
"wordCount": 6,
"characterCount": 31,
"isQuestion": true,
"isLongTail": true,
"containsSeed": true,
"country": "US",
"language": "en",
"scrapedAt": "2026-08-21T00:19:32.563Z"
}
```
Every field above is filled on **100%** of rows (measured). `relevance` and `suggestType` are
`null` on engines that do not publish them — Google Web and Bing do.
Each run also ends with one free `diagnostics` row and a free `error` row per failing engine,
so you can always tell the difference between "no keywords exist" and "something broke". The
diagnostics row includes `keywordsBySource`, the per-engine tally of what actually landed:
```json
{ "type": "diagnostics", "keywordsDelivered": 250, "keywordsBySource":
{ "google": 182, "youtube": 55, "amazon": 13 }, "duplicatesSkipped": 63,
"stopReason": "maxItemsReached" }
```
### Pricing
**$2.50 per 1,000 keywords** on the Gold plan tier — the price the Store card shows. Per keyword, by your Apify plan:
| Plan tier | Per 1,000 keywords |
|---|---:|
| Free | $5.00 |
| Bronze | $4.50 |
| Silver | $3.30 |
| **Gold** | **$2.50** |
| Platinum | $2.30 |
| Diamond | $2.20 |
**What is free:**
- duplicate keywords — found by five prefixes across three engines, billed once
- keywords removed by your filters
- failed and blocked lookups
- the `diagnostics` and `error` rows
- a run that returns nothing
- **the run itself** — there is no actor-start fee, which several competing keyword actors
charge at $0.005–$0.05 before returning a single row
Platform compute is included in the price rather than billed on top, so the number above is
the number.
**Staying in control — two independent ceilings, both on by default:**
- `maxKeywords` caps the run at **200** keywords unless you raise it.
- `maxCostUsd` is a hard spend ceiling, defaulting to **$5.00**.
- `maxKeywordsPerSeed` stops one broad seed eating the whole budget.
Whichever is reached first stops the run, and the free `diagnostics` row says which. You can
cap a run as low as **$0.02** — for comparison, `apify/google-search-scraper` will not let you
budget a run below $0.50.
### Use it from anywhere
```bash
curl -X POST "https://api.apify.com/v2/acts/vonsensey~google-keyword-ideas-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H 'Content-Type: application/json' \
-d '{"seeds":["coffee maker"],"maxKeywords":200}'
```
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("vonsensey/google-keyword-ideas-scraper").call(run_input={
"seeds": ["coffee maker"],
"sources": ["google", "youtube", "amazon"],
"expansions": ["seed", "questions", "alphabet"],
"maxKeywords": 1000,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
if row.get("type") == "keyword":
print(row["relevance"], row["keyword"])
```
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('vonsensey/google-keyword-ideas-scraper').call({
seeds: ['coffee maker'],
onlyQuestions: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```
Also available through the Apify integrations for **n8n, Make and Zapier**, and via **MCP** for
AI agents. Schedule it weekly and you have a keyword-trend feed.
### Who this is for
- **SEO teams** building topic clusters and content calendars from a handful of seeds
- **Content writers** who need the questions real people ask, not invented FAQ headings
- **PPC managers** harvesting long-tail and negative-keyword candidates
- **Amazon and eBay sellers** mining the buying-intent phrases shoppers actually type
- **YouTube creators** finding title and topic ideas from YouTube's own suggestion index
- **Agencies** running the same discovery across many client niches and locales
- **AI/LLM pipelines** that need a broad, deduplicated query set for retrieval or evaluation
### Input reference
| Field | Type | Default | What it does |
|---|---|---|---|
| `seeds` | array | `["coffee maker"]` | Terms to expand. Required. |
| `sources` | array | `["google"]` | Which of the 11 engines to query. |
| `expansions` | array | `["seed","questions","alphabet"]` | How each seed is fanned out. |
| `country` | string | `US` | Two-letter market code. |
| `language` | string | `en` | Language code (`en`, `de`, `pt-BR`, …). |
| `maxKeywords` | integer | `200` | Hard cap on billable keywords (max 50,000). |
| `maxKeywordsPerSeed` | integer | — | Optional per-seed cap. |
| `maxCostUsd` | number | `5.00` | Hard spend ceiling in USD. Raise it for large runs. |
| `onlyQuestions` | boolean | `false` | Keep question-shaped keywords only. |
| `onlyLongTail` | boolean | `false` | Keep keywords of 3+ words only. |
| `mustContainSeed` | boolean | `false` | Drop suggestions that drifted off-seed. |
| `minWordCount` | integer | `0` | Drop keywords shorter than this. |
| `excludeTerms` | array | `[]` | Drop keywords containing any of these. |
| `concurrency` | integer | `15` | Parallel lookups. |
| `proxy` | object | off | Optional; not needed for normal runs. |
**Cost planning.** Lookups per seed per engine: seed 1, questions 15, comparisons 11,
prepositions 12, numbers 10, A-Z suffix 26, A-Z prefix 26 — 101 for all seven. Expect roughly
10–15 raw suggestions per lookup before deduplication.
### Frequently asked
**Do I need a Google API key?** No. No key, no login, no account.
**Is the data live?** Yes — every run queries the engines in real time. Nothing is cached
between runs.
**Why did I get keywords that do not contain my seed?** Suggestion engines drift toward what
people actually search. Set `mustContainSeed: true` to keep only literal matches.
**Can I get search volume?** Not from this actor, and it will not pretend otherwise. See
"No fake search volume" above.
**How do I keep the bill predictable?** Both ceilings are already on: 200 keywords and $5.00
per run by default. Raise or lower either; the run stops at whichever binds first and tells
you which one it was.
**Which engines give the most?** Google Web by volume; eBay, YouTube and Amazon by *unique*
keywords. See the table above.
**Why did one of my engines return so few rows?** Two honest reasons, and `keywordsBySource`
in the diagnostics row shows you which. First, engines answer modified prefixes very
differently — for `how coffee maker`, Google returns 15 suggestions and Amazon returns 2,
because that is not a shopping query. Second, dedupe is global and a keyword is attributed to
the **first** engine that returned it, so heavily-overlapping engines show fewer rows while
still contributing to the union. Raise `maxKeywords`, or run one engine per job if you need
strict per-engine attribution.
**What if an engine breaks?** That engine emits one free `error` row and the run carries on
with the others. You are never charged for a failed lookup.
### Legal
Unofficial tool. **Not affiliated with, endorsed by, or sponsored by Google, YouTube,
Microsoft, Bing, Amazon, eBay, DuckDuckGo, Wikipedia or Yandex.** All trademarks belong to
their respective owners.
Reads only public, unauthenticated search-suggestion endpoints — no login, no personal data,
no paywall circumvention. Suggestion strings are aggregate query data, not personal data.
### Support
Questions, bugs and engine requests go in the **Issues** tab — first response within 24 hours.
> **Run it without configuring anything** — [Get keyword ideas from a single seed](https://apify.com/vonsensey/google-keyword-ideas-scraper/examples/keyword-ideas-from-one-seed), a ready-made example you can start as-is or copy.
### Use cases
- **Build a content plan from one seed.** A single term expands into the questions, comparisons and long-tail phrases people actually type.
- **Find PPC and listing terms.** Harvest the exact wording buyers use on the engine you advertise on, rather than guessing at it.
- **Write an FAQ that ranks.** The question expansion returns real who/what/why/how queries — one heading each.
- **Compare engines.** The same seed sent to several engines shows where demand differs, with every suggestion labelled by its source.
### Run it on a schedule
A one-off pull answers a question; a schedule answers it every day without you. Open **Schedules** in the Apify Console, point a cron at this Actor, and the dataset keeps filling on its own — no server, no cron box, no babysitting. Everything here is built to be re-run: you are billed per keyword delivered, so a scheduled run that finds nothing new costs nothing.
### FAQ
#### Do I need an SEO tool subscription?
No. There is no Ahrefs, Semrush or Keyword Planner account behind this — the terms come from the engines' own live suggestion endpoints.
#### Does it return search volume?
No, and no scraper that claims to should be trusted with it. What you get is the real demand signal: the phrases the engines themselves suggest to searchers. Pair it with a volume source if you need numbers.
#### Which engines can I pull from?
Google, Bing, DuckDuckGo, YouTube, Amazon and eBay among others — pick them per run, and each keyword is labelled with the engine it came from.
#### How many keywords does one seed produce?
Hundreds, depending on the expansions you enable — alphabet, questions, prepositions and comparisons each multiply the seed.
***
Something wrong, or a field you need that is missing? Open an issue on the **Issues** tab — it is read and it gets fixed. If this saved you time, a rating on the Store page helps the next person find it.
# Actor input Schema
## `seeds` (type: `array`):
The terms to expand. Each seed is fanned out across the selected engines and modifiers. Start broad ("coffee maker"), not narrow.
## `sources` (type: `array`):
Which suggestion corpora to mine. Each engine has a genuinely different index — Amazon and eBay surface buying intent, YouTube surfaces content ideas, Google surfaces everything.
## `expansions` (type: `array`):
How each seed is fanned out. More modes means more long-tail coverage and more lookups. 'Seed only' is a single lookup; 'A-Z' is 26.
## `country` (type: `string`):
Two-letter market code. Suggestions are strongly localised — the same seed returns different keywords per country.
## `language` (type: `string`):
Language code, for example en, de, fr, es, pt-BR.
## `maxKeywords` (type: `integer`):
Hard ceiling on billable keywords for the whole run. The run stops the moment it is reached. One seed across all engines and expansions can yield 3,000+ keywords, so this is your main cost control.
## `maxKeywordsPerSeed` (type: `integer`):
Optional. Keeps one broad seed from consuming the whole maxKeywords budget when you pass several. Leave empty for no per-seed limit.
## `maxCostUsd` (type: `number`):
Hard spend ceiling for this run, in USD. Defaults to $5.00 - raise it for large runs. The run stops before crossing it and says so in the diagnostics row.
## `onlyQuestions` (type: `boolean`):
Keep only question-shaped keywords — the ones that map to FAQ sections and People-Also-Ask style content.
## `onlyLongTail` (type: `boolean`):
Keep only keywords of three or more words.
## `mustContainSeed` (type: `boolean`):
Drop suggestions that drifted away from your seed entirely.
## `minWordCount` (type: `integer`):
Drop keywords shorter than this many words.
## `excludeTerms` (type: `array`):
Drop any keyword containing one of these substrings. Case-insensitive.
## `concurrency` (type: `integer`):
Parallel lookups. The default suits every normal run.
## `proxy` (type: `object`):
Optional. Runs fine without a proxy; a datacenter proxy group helps only on very large runs.
## Actor input object example
```json
{
"seeds": [
"coffee maker",
"espresso machine"
],
"sources": [
"google"
],
"expansions": [
"seed",
"questions",
"alphabet"
],
"country": "US",
"language": "en",
"maxKeywords": 200,
"maxCostUsd": 5,
"onlyQuestions": false,
"onlyLongTail": false,
"mustContainSeed": false,
"minWordCount": 0,
"excludeTerms": [],
"concurrency": 15,
"proxy": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `keywords` (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 '