# Keyword Suggestions - Google, YouTube, Bing & Amazon (`dariandanciu/keyword-suggestions-scraper`) Actor

Turn seed keywords into hundreds of long-tail keyword ideas from Google, YouTube, Bing, Amazon and DuckDuckGo autocomplete. A-Z and question expansion, popularity ranking, and search intent (question, comparison, commercial, local) for every idea.

- **URL**: https://apify.com/dariandanciu/keyword-suggestions-scraper.md
- **Developed by:** [Darian Danciu](https://apify.com/dariandanciu) (community)
- **Categories:** SEO tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 keyword ideas

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?

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

## Keyword Suggestions - Google, YouTube, Bing, Amazon autocomplete

Turn a few seed keywords into **hundreds of long-tail keyword ideas** from what people actually
type into **Google, YouTube, Bing, Amazon and DuckDuckGo**. Every idea comes **ranked by
popularity** and **tagged with search intent**, ready to sort in a spreadsheet.

### Why this one

- **Five engines in one run.** Google for web content, YouTube for video topics, Amazon for product
  and listing keywords, Bing and DuckDuckGo for a second opinion.
- **Ranked, not just listed.** Each keyword is expanded into dozens of queries (a-z, 0-9,
  question words, prepositions). `appearances` counts how many of those queries returned the same
  idea, which is a strong popularity signal. Results are sorted by it.
- **Search intent built in.** Every idea is tagged `question`, `comparison`, `commercial`, `local`
  or `informational`, so you can pull FAQ topics, "vs" articles or buying-guide keywords in one filter.
- **Deeper long tail on request.** Second round re-expands the 10 strongest ideas.
- **Clean output.** Duplicates across expansions and letter case are merged; the seed itself is
  left out unless you ask for it.
- **You only pay for ideas.** Failed lookups are free and listed in `RUN_SUMMARY`.

### Example

Seed `embedded c++`, Google, alphabet + questions expansion:

| rank | suggestion | appearances | intent |
|---|---|---|---|
| 1 | embedded c++ code example | 16 | informational |
| 2 | difference between c++ and embedded c++ | 11 | comparison |
| 3 | embedded c++ interview questions | 4 | informational |
| 4 | is c++ embedded | 4 | question |
| 6 | what is embedded c++ used for | 3 | question |

One seed on one engine with alphabet + questions typically returns **150-400 ideas**.

### Output

```json
{
    "seed": "usb c hub",
    "engine": "amazon",
    "suggestion": "usb c hub for macbook pro",
    "rank": 3,
    "appearances": 9,
    "bestPosition": 1,
    "foundVia": "f",
    "intent": "informational",
    "wordCount": 6,
    "language": "en",
    "country": "US"
}
```

### Use cases

- **SEO and content plans:** find long-tail topics and the questions people ask.
- **YouTube channels:** pick video titles people already search for.
- **Amazon sellers:** find the phrases shoppers type to fill titles and backend keywords.
- **PPC:** build keyword and negative-keyword lists fast.

### Pricing

Pay per keyword idea. See the Pricing tab. Failed lookups are free.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/dariandanciu~keyword-suggestions-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["standing desk"],"engines":["google","amazon"],"expand":["alphabet","questions"]}'
```

### Good to know

- Autocomplete shows what people type, not exact search volume. Use `appearances` and `rank` to
  prioritize, and a volume tool if you need monthly numbers.
- Suggestions depend on language and country; set both for local markets.
- Amazon suggests only shopping-related phrases, so non-product seeds return few ideas there.

### Feedback

Want another engine or a field? Open an issue on the Issues tab.

# Actor input Schema

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

Topics to expand into keyword ideas, one per line.

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

Where to collect autocomplete suggestions. Each engine reflects what people type there.

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

Extra queries per keyword. Alphabet adds a-z and 0-9 after the keyword; Questions puts how/what/why/etc. in front; Prepositions adds for/with/vs/near and more.

## `secondRound` (type: `boolean`):

Run the 10 strongest suggestions through the engine again for more specific ideas.

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

Two-letter language code, e.g. en, de, es, fr.

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

Two-letter country code, e.g. US, GB, DE, IN.

## `amazonMarket` (type: `string`):

Which Amazon store to read suggestions from (Amazon engine only).

## `includeSeed` (type: `boolean`):

Keep the exact seed keyword in the results when an engine suggests it.

## `maxSuggestionsPerKeyword` (type: `integer`):

Keep only the top N, ranked by how many queries returned them. 0 = all.

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

Apify Proxy is recommended. If an engine rate-limits, requests switch to residential proxies automatically.

## Actor input object example

```json
{
  "keywords": [
    "standing desk",
    "learn python"
  ],
  "engines": [
    "google"
  ],
  "expand": [
    "alphabet",
    "questions"
  ],
  "secondRound": false,
  "language": "en",
  "country": "US",
  "amazonMarket": "US",
  "includeSeed": false,
  "maxSuggestionsPerKeyword": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per unique suggestion per seed keyword and engine, ranked by popularity.

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

Suggestions found per keyword and engine, and any failed lookups (not charged).

# 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": [
        "standing desk",
        "learn python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dariandanciu/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 = { "keywords": [
        "standing desk",
        "learn python",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("dariandanciu/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 '{
  "keywords": [
    "standing desk",
    "learn python"
  ]
}' |
apify call dariandanciu/keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

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