# Keyfern — Keyword Ideas & Autocomplete: Google, YouTube, Amazon (`cybermax/keyword-ideas`) Actor

Keyword research and Google autocomplete scraper from real searches: seeds in, hundreds of long-tail keyword ideas out from Google, YouTube, Bing, Amazon and DuckDuckGo autocomplete, with intent, clusters, a signal score, Google Trends verdicts and new-keyword alerts. No invented volumes.

- **URL**: https://apify.com/cybermax/keyword-ideas.md
- **Developed by:** [CyberMax](https://apify.com/cybermax) (community)
- **Categories:** SEO tools, Marketing, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Keyfern — keyword ideas & autocomplete scraper for Google, YouTube, Bing and Amazon

**Keyword research from real searches: give it a seed keyword, get back hundreds of long-tail keyword ideas**
that people actually type into Google, YouTube, Bing, Amazon and DuckDuckGo. Every idea is deduped across
engines and comes with its search intent, a topic cluster, the engines that suggested it and a 0–100 signal
score. Optionally, the best ideas also get a **Google Trends verdict: rising, falling, spiking or stable**.
It costs **$0.001 per keyword idea** ($1 per 1,000) and **$0.003 per trend verdict**.

**First try:** the prefilled input (seed `standing desk`, best 8 ideas, no trend check) runs in about 15 seconds
and costs about **$0.008**.

### Why Keyfern

- **Five autocomplete engines in one run.** Most autocomplete scrapers read Google only. Keyfern asks Google
  Search, YouTube, Bing, Amazon and DuckDuckGo (pick any mix) and merges the answers. A phrase suggested by
  several engines is a stronger idea, and the score shows it.
- **The whole long tail, not ten suggestions.** Each seed is expanded A–Z (`standing desk a` … `standing desk z`),
  with question words (`how`, `what`, `why`, `can`, `is`, `does`, …) and with prepositions and comparisons
  (`for`, `with`, `without`, `near`, `vs`, …). One seed on 3 engines = 147 lookups in a few seconds. In our test,
  `standing desk` on all five engines gave 1,041 unique ideas.
- **Sorted and labelled, ready to use.** Each idea is tagged `question`, `commercial`,
  `transactional`, `local`, `comparison` or `informational`, grouped into a cluster (`converter`, `treadmill`,
  `ikea`…), and ranked. A per-seed `SUMMARY` lists the top clusters, the top questions (FAQ and blog topics) and
  the intent mix.
- **Trend direction, not invented search volume.** Autocomplete doesn't reveal search volume, and Keyfern
  doesn't make one up. Instead it can check the top N ideas on Google Trends (the same engine as our
  [Swellmeter](https://apify.com/cybermax/google-trends) Actor) and tell you whether interest is growing.
- **New-keyword alerts.** `monitor: true` returns only ideas you haven't received before for your seeds, plus
  ideas whose trend verdict flipped, so a weekly scheduled run costs only for what's new.

**Real example** (live run, 2026-09-23, seed `standing desk`, Google + YouTube + Bing + Amazon, US):

> 196 of 196 autocomplete calls answered in about 6 seconds. Top ideas: standing desk chair · standing desk ikea ·
> standing desk with drawers · standing desk with storage · standing desk with wheels. Biggest clusters: walking,
> treadmill, gaming, keyboard. Google Trends: "standing desk chair" **rising** (+74% last quarter of the year vs
> the first), "standing desk ikea" **stable**.

### What you get (one record per keyword idea)

| Field | Meaning |
|---|---|
| `keyword` | The suggested search phrase (lowercased, deduped) |
| `seed` | The seed it came from |
| `signalScore` | 0–100 relative ranking signal: how many engines suggest it, how high, how often, and whether it shows up for the bare seed. **Not search volume.** |
| `intent` | `question`, `commercial`, `transactional`, `local`, `comparison` or `informational` (inferred from the wording) |
| `cluster`, `modifier` | The main word the idea adds to the seed, and all the words it adds |
| `sources`, `sourceCount` | Engines that suggested it |
| `bestPosition`, `hits` | Best rank in any suggestion list (1 = top), and how many lookups returned it |
| `suggestedOnSeedQuery` | `true` if the engine suggests it for the bare seed (the strongest ideas) |
| `foundVia` | How it was found: `seed`, `alphabet:c`, `question:how`, `preposition:vs`… |
| `trend` | Only for the top N ideas: `{ status, direction, trendChangePct, recentChangePct, peakDate, exploreUrl }` |
| `language`, `country`, `fetchedAt` | Run settings and time |
| `change`, `changedFields`, `previousTrendDirection` | Monitor mode only: `new` or `changed` (trend verdict flipped) |

The key-value store record `SUMMARY` has, per seed: idea count, intent mix, top 15 clusters, top 20 ideas,
top 15 questions, and per-engine success counts.

### Input

```json
{ "seeds": ["standing desk", "cold brew"], "sources": ["google", "youtube", "bing", "amazon"], "trendCheckTop": 5 }
```

| Option | Default | |
|---|---|---|
| `seeds` | | Up to 50 seed keywords |
| `sources` | `google, youtube, bing` | Any of `google`, `youtube`, `bing`, `amazon`, `duckduckgo` |
| `language`, `country` | `en`, `US` | Language and country of the suggestions (also picks the Amazon marketplace and the Trends region) |
| `expandAlphabet`, `expandQuestions`, `expandPrepositions` | all on | Which expansions to run |
| `mustContainSeed` | `true` | Drop suggestions that don't contain the seed's words |
| `maxIdeasPerSeed` | 300 | Best N ideas kept per seed, which also caps the cost (300 ideas = $0.30) |
| `minSignalScore` | 0 | Keep only ideas at or above this score |
| `intents` | all | Keep only some intents, e.g. `["question"]` for FAQ research |
| `trendCheckTop` | 5 | Google Trends verdict for the N best ideas per seed (0 = off, max 25) |
| `trendTimeRange` | `today 12-m` | Trends window: past 30 days, 90 days, 12 months or 5 years |
| `monitor` | `false` | Only ideas not returned by an earlier monitor run, plus trend-verdict changes (see below) |
| `monitorKey` | | Optional name for the monitor's saved state, to keep several seed sets apart |

### Monitor mode: only new keyword ideas since the last run

Turn on `monitor` for scheduled runs. Keyfern remembers, per seed, language and country, every idea it already
returned and outputs only:

- ideas it has never returned for that seed: `"change": "new"`;
- ideas whose Google Trends verdict changed (both runs had a verdict): `"change": "changed"`,
  `"changedFields": ["trend.direction"]` and `"previousTrendDirection"`.

Shape of a monitor record (other fields as in the normal output below):

```json
{ "seed": "standing desk", "keyword": "…", "change": "changed", "changedFields": ["trend.direction"], "previousTrendDirection": "stable", "trend": { "status": "ok", "direction": "rising", "…": "…" } }
```

Unchanged ideas are left out and not charged. The first monitor run returns everything (`"change": "new"`).
Ideas that drop out of autocomplete for a while aren't reported again when they come back. `maxIdeasPerSeed`
applies before the comparison, so "new" means "new in your top N". The `SUMMARY` record gets new/changed/unchanged
counts. State lives in your named key-value store `keyword-ideas-monitor` (one record per `monitorKey`, or derived
from the seeds, sources, language and country); delete the record to start over.

### Ready-made inputs (first try in one click)

**No account yet?** See real results first on the free demo page: [keyword ideas for 20 popular topics](https://huggingface.co/spaces/shaw276/what-people-search).

Paste one into the **JSON** tab of the input form (or send it to the API) and press **Start**. Each is sized so the first run is quick and cheap; you pay only for results (Apify's compute is included in the price).

| Preset | What you get | Cost |
|---|---|---|
| 8 long-tail ideas for one seed | 8 ideas with intent, cluster, engines and signal score | $0.008 |
| Questions people ask | 8 question-style searches (how/why/can…) | $0.008 |
| Amazon buyer searches + 1 trend verdict | 5 product searches + a rising/falling verdict for the top one | $0.008 |

**8 long-tail ideas for one seed**

```json
{"seeds": ["standing desk"], "maxIdeasPerSeed": 8, "trendCheckTop": 0}
```

**Questions people ask**

```json
{"seeds": ["solar panels"], "intents": ["question"], "maxIdeasPerSeed": 8, "trendCheckTop": 0}
```

**Amazon buyer searches + 1 trend verdict**

```json
{"seeds": ["air fryer"], "sources": ["amazon"], "maxIdeasPerSeed": 5, "trendCheckTop": 1}
```

Same thing from a script (returns the results directly):

```bash
curl -s -X POST "https://api.apify.com/v2/acts/cybermax~keyword-ideas/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' -d '{"seeds": ["standing desk"], "maxIdeasPerSeed": 8, "trendCheckTop": 0}'
```

### Output (trimmed, real record)

```json
{
  "seed": "standing desk",
  "keyword": "standing desk chair",
  "signalScore": 100,
  "intent": "informational",
  "cluster": "chair",
  "sources": ["amazon", "bing", "google", "youtube"],
  "bestPosition": 1,
  "hits": 11,
  "suggestedOnSeedQuery": true,
  "foundVia": ["alphabet:c", "seed", "question:when"],
  "trend": { "status": "ok", "direction": "rising", "trendChangePct": 74.3, "recentChangePct": -25.9, "peakDate": "2026-04-12" }
}
```

### Pricing

| Event | Price | Charged when |
|---|---|---|
| `keyword-idea` | $0.001 | One unique idea is returned (capped by `maxIdeasPerSeed`) |
| `trend-checked` | $0.003 | One idea gets a Google Trends verdict. No-data and failed checks are free |

Typical costs: one seed with 300 ideas and 5 trend verdicts = **$0.315**. 100 question ideas only
(`intents: ["question"]`, `maxIdeasPerSeed: 100`, `trendCheckTop: 0`) = **$0.10**. Set a maximum charge per run
in Apify and Keyfern stops cleanly when it's reached.

### When NOT to use Keyfern

- **You need search volume, CPC or keyword difficulty numbers.** Autocomplete doesn't expose them; use a
  paid-data SEO tool. Keyfern gives you real phrasing and trend direction, never estimated volumes.
- **You need the full Trends picture for a few keywords** (timeline, regions, related queries): use
  [Swellmeter — Google Trends](https://apify.com/cybermax/google-trends).
- **Very long seeds** (6+ words) get few suggestions; use 1–3 word topics.

### FAQ

**Is this a Google Keyword Planner alternative?** For ideas and phrasing, yes: it expands a topic into the long-tail searches people actually type on Google, YouTube, Bing and Amazon, with a Google Trends verdict on the best ones. It doesn't estimate search volume or CPC (see "When NOT to use Keyfern").

**How many keyword ideas do I get per seed?** Up to 2,000 (`maxIdeasPerSeed`, default 300), ranked by how many engines suggest a phrase and how high. Up to 50 seeds per run.

**Can I get only question keywords for FAQ or blog posts?** Yes: `"intents": ["question"]`. The question expansion ("how/what/why … + seed") is on by default.

**Which languages and countries?** Any two-letter `language` and `country` (en/US, de/DE, fr/FR, ja/JP…). The country also picks the Amazon marketplace and the Google Trends region.

**How much does it cost compared with Semrush or Ahrefs scrapers?** $0.001 per idea. The most-used keyword Actors on the Store charge $0.002–$0.012 per keyword result (Apify Store, 24 Sep 2026), and Keyfern needs no SEO-suite account.

**Can an AI agent use it?** Yes, through Apify's MCP server (`https://mcp.apify.com/?tools=cybermax/keyword-ideas`), and it's in the official MCP Registry.

### Notes

Keyfern reads the public autocomplete endpoints that each engine's own search box uses: no login, no API
key, no personal data. Suggestions change over time and by country and language. Calls go out directly and
fall back to Apify Proxy when an engine throttles.

### Run it on a schedule

Weekly new-keyword report: Apify Console → **Schedules** → **Create new** → cron `0 8 * * 1` (8:00 every Monday,
or `0 8 * * *` daily) → **Add Actor** → `cybermax/keyword-ideas` with your input (or a saved task) including
`"monitor": true`. Or with the API:

```http
POST https://api.apify.com/v2/schedules?token=YOUR_TOKEN
{
  "name": "weekly-keyword-ideas",
  "cronExpression": "0 8 * * 1",
  "timezone": "America/New_York",
  "isEnabled": true,
  "actions": [{
    "type": "RUN_ACTOR",
    "actorId": "cybermax/keyword-ideas",
    "runInput": { "body": "{\"seeds\": [\"standing desk\", \"cold brew\"], \"maxIdeasPerSeed\": 300, \"trendCheckTop\": 5, \"monitor\": true}", "contentType": "application/json" }
  }]
}
```

With monitor mode a scheduled run only pays for new ideas and changed trend verdicts. To get notified, add a
webhook, Slack or email notification on **Run succeeded** in the Actor's **Integrations** tab.

### Integrations

**Make:** Apify app → "Run an Actor" (`cybermax/keyword-ideas`, input JSON, "Run synchronously" on) → "Get dataset
items" → Google Sheets "Add a row" / Airtable.

**Zapier:** Apify app → "Run Actor" action (or "Finished Actor Run" trigger for your schedule) → "Find dataset
items" → Google Sheets / Notion / Slack.

**n8n:** Apify node ("Run actor and get dataset"), or an HTTP Request node:

```
POST https://api.apify.com/v2/acts/cybermax~keyword-ideas/run-sync-get-dataset-items?token=YOUR_TOKEN
{"seeds": ["standing desk"], "intents": ["question"], "maxIdeasPerSeed": 50, "trendCheckTop": 0}
```

**Google Sheets:** Apify's Google Sheets integration (Actor → Integrations), or paste into a cell to pull the last
run as CSV:

```
=IMPORTDATA("https://api.apify.com/v2/acts/cybermax~keyword-ideas/runs/last/dataset/items?format=csv&fields=keyword,signalScore,intent,cluster,change&token=YOUR_TOKEN")
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("cybermax/keyword-ideas").call(run_input={"seeds": ["cold brew"], "sources": ["google", "youtube", "amazon"], "maxIdeasPerSeed": 100})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["signalScore"], item["intent"], item["keyword"])
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('cybermax/keyword-ideas').call({ seeds: ['standing desk'], intents: ['question'], trendCheckTop: 0 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => i.keyword));
```

**AI agents (MCP):** Keyfern is a tool in any MCP client via Apify's hosted MCP server,
`https://mcp.apify.com/?tools=cybermax/keyword-ideas` (header `Authorization: Bearer <your Apify token>`). The
records are compact and flat, so an agent can pick blog topics, FAQ questions, product keywords or video titles
directly. Claude Desktop / Cursor config:

```json
{ "mcpServers": { "keyfern": { "url": "https://mcp.apify.com/?tools=cybermax/keyword-ideas", "headers": { "Authorization": "Bearer YOUR_TOKEN" } } } }
```

Example prompt: *"Find 50 question keywords about cold brew that are rising on Google Trends."*

### Also from CyberMax

- [Swellmeter — Google Trends](https://apify.com/cybermax/google-trends): the full Trends picture (timeline, related and rising queries, regions, trending now) for your best ideas.
- [Linkheft — Domain authority](https://apify.com/cybermax/domain-authority): how strong the sites ranking for your keywords are.
- [SnapScout — Website screenshots](https://apify.com/cybermax/website-screenshot): screenshot and text of the pages ranking for your keywords.
- [DomainDNA — Tech stack & domain intel](https://apify.com/cybermax/domain-intel): what the competing sites are built with.
- [Gripeline — App reviews](https://apify.com/cybermax/app-reviews): the words real users use in App Store and Google Play complaints.

All tools: [Boardroom Buys](https://apify.com/cybermax/sec-insider-tracker) · [HireHeat](https://apify.com/cybermax/hiring-signals) · [HireHeat Jobs](https://apify.com/cybermax/career-site-jobs) · [Hollerdex](https://apify.com/cybermax/website-contacts) · [Printwren](https://huggingface.co/spaces/shaw276/docs-pages-as-pdfs?soon=html-to-pdf) · [Logolark](https://huggingface.co/spaces/shaw276/saas-logos-brand-colors?soon=logo-finder)

### Changelog

- 2026-09-23: Monitor mode (`monitor`, `monitorKey`: only keyword ideas not seen before for your seeds, plus trend-verdict changes), schedule & integration recipes.

Made by CyberMax.

# Actor input Schema

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

One topic per line (up to 50). Each seed is expanded through every chosen engine's autocomplete into long-tail keyword ideas.

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

Which engines to ask. A phrase suggested by several engines scores higher. Amazon = product/buyer searches; YouTube = video topics.

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

Two-letter language code (en, de, fr, es, pt, ja…).

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

Two-letter country code (US, GB, DE, IN…). Also picks the Amazon marketplace and the Google Trends region.

## `expandAlphabet` (type: `boolean`):

Ask "seed a" … "seed z" (26 extra lookups per engine). Most of the long tail comes from here.

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

Ask "how/what/why/where/when/which/who/can/is/are/does/should + seed" (12 lookups per engine). Great for FAQ and blog topics.

## `expandPrepositions` (type: `boolean`):

Ask "seed for/with/without/to/near/vs/like/and/or/versus" (10 lookups per engine).

## `mustContainSeed` (type: `boolean`):

Drop suggestions that don't contain every word of the seed (off-topic breakouts). Turn off to keep brand-first phrases like "flexispot".

## `maxIdeasPerSeed` (type: `integer`):

Best ideas kept per seed, ranked by signal score. You pay per idea returned, so this caps the cost of a seed.

## `minSignalScore` (type: `integer`):

0–100. Drop weak ideas (seen on one engine, low in the list). 30+ keeps roughly the stronger half.

## `intents` (type: `array`):

Leave empty for all. Intent is inferred from the wording (heuristic).

## `trendCheckTop` (type: `integer`):

Adds a rising/falling/spiking/stable verdict and % change from Google Trends to the N best ideas per seed (0 = off). Charged per keyword that gets a verdict.

## `trendTimeRange` (type: `string`):

Window used for the trend verdict.

## `maxConcurrency` (type: `integer`):

Autocomplete calls in flight at once.

## `monitor` (type: `boolean`):

For scheduled runs (e.g. a weekly new-keyword report). Remembers which ideas were already returned for each seed, language and country, and outputs (and charges) only ideas never returned before (change: "new") plus ideas whose Google Trends verdict changed, e.g. stable → rising (change: "changed"). Unchanged ideas are left out and not charged. The first monitor run returns everything, like a normal run.

## `monitorKey` (type: `string`):

Name for this watchlist's saved state, so several seed sets can be monitored separately (letters, digits, - \_ . only). Empty = derived from the seeds, sources, language and country. State is kept in your named key-value store "keyword-ideas-monitor".

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

Used only as a fallback when an engine throttles a direct call.

## Actor input object example

```json
{
  "seeds": [
    "standing desk"
  ],
  "sources": [
    "google",
    "youtube",
    "bing"
  ],
  "language": "en",
  "country": "US",
  "expandAlphabet": true,
  "expandQuestions": true,
  "expandPrepositions": true,
  "mustContainSeed": true,
  "maxIdeasPerSeed": 8,
  "minSignalScore": 0,
  "intents": [],
  "trendCheckTop": 5,
  "trendTimeRange": "today 12-m",
  "maxConcurrency": 8,
  "monitor": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "seeds": [
        "standing desk"
    ],
    "maxIdeasPerSeed": 8,
    "trendCheckTop": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cybermax/keyword-ideas").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": ["standing desk"],
    "maxIdeasPerSeed": 8,
    "trendCheckTop": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cybermax/keyword-ideas").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": [
    "standing desk"
  ],
  "maxIdeasPerSeed": 8,
  "trendCheckTop": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cybermax/keyword-ideas --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cybermax/keyword-ideas"
        }
    }
}
```

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/EWjDNhChx7MgpjULg/builds/iaNgENy9EKQWSuB3z/openapi.json