# Keyword Research Scraper – Google, YouTube, Amazon & App Store (`nourishing_courier/keyword-research-scraper`) Actor

Keyword research scraper for autocomplete suggestions from Google, YouTube, Bing, Amazon, App Store, DuckDuckGo and eBay in one run. Alphabet, question and preposition expansion turns one seed into hundreds of long-tail keyword ideas. No API key, no proxy, pay only per keyword delivered.

- **URL**: https://apify.com/nourishing\_courier/keyword-research-scraper.md
- **Developed by:** [Ani Björkström](https://apify.com/nourishing_courier) (community)
- **Categories:** SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 keyword delivereds

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

## Keyword Research Scraper – Google, YouTube, Amazon & App Store

This keyword research scraper pulls **autocomplete keyword suggestions from seven engines in one
run**: Google, YouTube, Bing, Amazon, the App Store, DuckDuckGo and eBay. Type one seed such as
`ai tools` and get back hundreds of long-tail keyword ideas that real people are typing right now,
as flat rows you can drop into a spreadsheet, a content plan or an LLM pipeline.

Three things set this keyword suggestions scraper apart from every other keyword research scraper on the Store:

- **No API key, no login, no proxy.** Every source is a public autocomplete endpoint, so a run
  with the default input finishes in seconds and costs almost nothing in compute.
- **Built-in expansion.** Alphabet soup (`seed a` … `seed z`), question words (`how seed`,
  `why seed` …), prepositions (`seed for`, `seed vs` …) and an optional depth-2 pass that feeds
  every discovered keyword back in as a new query.
- **Pay only for keywords you receive.** One flat price per delivered keyword row. Sources that
  return nothing cost nothing.

### Why autocomplete is the best free keyword source

Autocomplete is not a guess. Google, YouTube, Amazon and the App Store only suggest completions
that enough people have actually searched for, ranked by how often they search for them. That makes
a Google autocomplete scraper the fastest way to find:

- **long-tail keywords** with clear intent (`ai tools for small business owners`),
- **questions people ask** (`how ai tools work`, `what ai tools are free for students`) – the
  free alternative to scraping People Also Ask,
- **comparison and commercial intent** (`notion vs obsidian`, `ai tools like chatgpt`),
- **platform-specific demand** – what people search on YouTube is not what they search on Amazon
  or in the App Store, and this actor shows all of them side by side.

The **alphabet soup** method is how every keyword research tool from Ubersuggest to KeywordTool.io gets its
data: send the seed plus each letter of the alphabet and collect what comes back. Twenty-six extra
queries per seed typically turn 10 suggestions into 200–500 unique keywords. Question and
preposition expansion do the same for informational and comparison intent.

### What you get

One row per keyword, identical fields whichever source it came from:

| Field | Description |
|---|---|
| `keyword` | The suggested keyword or phrase |
| `source` | `google`, `youtube`, `bing`, `amazon`, `appstore`, `duckduckgo` or `ebay` |
| `seed` | The seed keyword this suggestion came from |
| `modifier` | The expansion token that produced it (`how`, `for`, `a` …) or `null` for the bare seed |
| `query` | The exact query string sent to the engine, e.g. `how ai tools` |
| `level` | `1` = from the seed or its modifiers, `2` = from the depth-2 re-expansion |
| `position` | Rank inside the engine's answer for that query (1 = top suggestion) |
| `relevance` | Google's own relevance score for the suggestion (Google only, `null` elsewhere) |
| `language`, `country` | The locale the query was made in |
| `url` | The exact request URL, so every row is reproducible |
| `scrapedAt` | ISO 8601 UTC timestamp |

Keywords are de-duplicated per source, and the seed itself is never returned as a result. A source
and seed that yields nothing produces a single row with an `error` field explaining why, so the run
never quietly succeeds with an empty dataset.

**Search volume is not included.** Autocomplete endpoints do not expose it, and any actor that
claims to get volume from autocomplete is estimating. Use `position` and Google's `relevance` as a
demand signal, and pair this actor with a volume tool (Google Keyword Planner, DataForSEO or a
volume actor on the Store) for the shortlist you actually want numbers on.

### Input

The default input is enough to try the keyword research scraper – it researches `ai tools` on six sources with question
expansion and returns roughly 500 keywords in a few seconds.

```json
{
  "seedKeywords": ["ai tools"],
  "sources": ["google", "youtube", "bing", "amazon", "appstore", "duckduckgo"],
  "language": "en",
  "country": "us",
  "expandQuestions": true,
  "expandPrepositions": false,
  "expandAlphabet": false,
  "expandDigits": false,
  "depth": 1,
  "maxKeywordsPerSeed": 500
}
```

A full content-planning run for a YouTube creator:

```json
{
  "seedKeywords": ["ai for finance", "fp&a", "financial modeling"],
  "sources": ["google", "youtube"],
  "expandQuestions": true,
  "expandPrepositions": true,
  "expandAlphabet": true,
  "depth": 2,
  "maxKeywordsPerSeed": 2000
}
```

An Amazon seller checking a niche in three marketplaces means three runs (one `country` each),
or one run per marketplace on a schedule:

```json
{ "seedKeywords": ["yoga mat"], "sources": ["amazon", "ebay"], "country": "de", "expandAlphabet": true }
```

#### Options

- **Seed keywords** – one per line. Each seed is sent to every selected source.
- **Sources** – any mix of `google`, `youtube`, `bing`, `amazon`, `appstore`, `duckduckgo`, `ebay`.
- **Language / Country** – `language` drives Google, YouTube, Bing and DuckDuckGo (`en`, `de`,
  `sv`, `ja` …). `country` picks the Google/Bing/DuckDuckGo region and also selects the Amazon
  marketplace (22 supported, from `us` and `gb` to `jp`, `in`, `br`, `ae`), the App Store storefront
  (50+) and the eBay site (19). An unsupported country for those three falls back to the US with a
  warning in the log – the run still completes.
- **Expand with question words** – prepends who / what / why / how / when / where / which / can /
  does / is / are / should / will. 13 extra queries per seed and source.
- **Expand with prepositions** – appends for / with / without / near / to / like / vs / versus /
  and / or. 10 extra queries.
- **Expand with a-z** – appends every letter. 26 extra queries. This is where the bulk of
  long-tail keyword ideas come from.
- **Expand with 0-9** – appends every digit. Good for products, years and versions.
- **Depth** – `2` sends every level-1 keyword back to the same source as a new query until the
  cap is hit. Multiplies results roughly 5–10x.
- **Maximum keywords per seed** – per seed and source. This is your cost ceiling.

Request count per source and seed = 1 + (13 if questions) + (10 if prepositions) + (26 if
alphabet) + (10 if digits), plus up to the cap at depth 2. The actor runs eight requests in
parallel with small pauses, retries politely on 429/5xx, and isolates every source so one engine
being down never affects the others.

### Use cases

- **SEO agencies and content marketers** – run the keyword research scraper on a client's core terms, build topic clusters from Google and Bing suggestions,
  then map questions to FAQ sections and H2s. Export to Google Sheets and hand the writer a brief.
- **YouTube creators** – YouTube autocomplete is the closest thing to a free YouTube keyword tool.
  Research `seed` + questions on the `youtube` source, sort by `position`, and you have a month of
  video titles people are already searching for. This actor was built by a finance YouTuber for
  exactly that workflow.
- **Amazon and eBay sellers** – Amazon keyword research for listings and PPC. Amazon's completion
  API returns the terms shoppers type in that marketplace, in that language, ranked by demand.
- **App developers (ASO)** – App Store keyword research: the `appstore` source returns what people
  type into the App Store search box, including competitor app names, for 50+ storefronts.
- **PPC teams** – generate negative keyword lists fast. Alphabet expansion surfaces the `free`,
  `crack`, `jobs` and `salary` variants you want excluded from a commercial campaign.
- **AI content pipelines and RAG builders** – flat rows with `source`, `modifier` and `level` are
  ready for an LLM to cluster into intents, or for an agent to call through MCP.
- **Market researchers** – use one keyword research scraper to compare how demand for the same seed differs across Google, YouTube and
  Amazon, or across `country` values, without paying for a seat on an enterprise SEO suite.

### Pricing

Pay per event: the keyword research scraper charges per **keyword row delivered** to the dataset. Sources or seeds that
return nothing cost nothing, error rows are never charged, and you can cap spend per seed and
source with `maxKeywordsPerSeed`. There is no actor-start fee and no separate charge per source –
a keyword from Amazon costs the same as one from Google.

A typical run of one seed on six sources with question expansion returns ~500 keywords. The same
seed with alphabet and prepositions on Google and YouTube at depth 2 usually returns 2,000–4,000.

### Integrations

Every row from the keyword research scraper is flat JSON, so the dataset drops straight into Google Sheets, Airtable, a CSV export,
n8n, Make, Zapier or an LLM prompt. Run it on a schedule and diff the results to see new keywords
appear week over week.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("nourishing_courier/keyword-research-scraper").call(run_input={
    "seedKeywords": ["ai tools"],
    "sources": ["google", "youtube"],
    "expandAlphabet": True,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["source"], row["position"], row["keyword"])
```

**JavaScript**

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });
const run = await client.actor("nourishing_courier/keyword-research-scraper").call({
  seedKeywords: ["yoga mat"],
  sources: ["amazon", "ebay"],
  country: "gb",
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => r.keyword));
```

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/nourishing_courier~keyword-research-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN&format=csv" \
  -H "Content-Type: application/json" \
  -d '{"seedKeywords": ["fp&a"], "sources": ["google"], "expandQuestions": true}'
```

**n8n / Make / Zapier** – use the Apify node or module, pick this actor, paste the JSON input above
and connect the dataset to a Google Sheets "append rows" step. **MCP** – expose the actor through
Apify's MCP server and an AI agent can run keyword research as a tool call.

### Limits and fair use

This keyword research scraper reads the same public autocomplete endpoints a browser calls when you type into a search
box; no personal data is collected, only the suggestion strings. Each engine returns roughly 8–15
suggestions per query (Bing up to 25), so the expansion options are how you get volume. Very large
depth-2 runs across many seeds send thousands of requests; the actor spaces them out and retries
on rate limits, and the `Proxy` option in Advanced is there if you ever need it, but none of the
sources need one at normal volumes. Autocomplete answers change daily and by locale – that is the
point – so `scrapedAt`, `language` and `country` are on every row. Search volume, CPC and
difficulty are not part of what these endpoints expose and are not claimed.

### FAQ

#### Is this keyword research scraper free?

You pay per keyword delivered, nothing else, which makes it a near-free Google autocomplete scraper for small jobs. Apify's free plan credit covers thousands of keywords
per month, and there is no API key to buy from Google, Amazon or anyone else.

#### How many keywords do I get per seed?

Bare seed with question expansion on six sources: about 500. Add alphabet, prepositions and depth
2 on Google and YouTube and expect 2,000–4,000 per seed. `maxKeywordsPerSeed` caps it.

#### Does it return search volume?

No. Autocomplete does not expose volume, so this actor does not invent it. It returns each
engine's own ranking (`position`) and Google's `relevance` score, which is the demand signal Google
itself uses to order suggestions. Feed the shortlist to a volume tool if you need numbers.

#### Can I scrape YouTube keyword suggestions without an API key?

Yes. The `youtube` source uses YouTube's public suggest endpoint, no Data API quota involved. It
works with any `language` and `country`.

#### Which Amazon marketplaces are supported?

US, UK, DE, FR, IT, ES, CA, JP, IN, AU, SE, NL, MX, BR, SG, AE, SA, PL, TR, EG and BE, chosen by
the `country` field. Each marketplace answers in its own language.

#### Does it work for App Store ASO keyword research?

Yes. The `appstore` source returns App Store search hints for 50+ storefronts, including the
competitor app names people type. It is the same endpoint the App Store app uses.

#### What is the alphabet soup method?

Append every letter a–z to your seed and collect the autocomplete for each. `ai tools a` gives
`ai tools and automation`, `ai tools b` gives `ai tools for business` and so on. Turn on **Expand
with a-z** and the actor does it for every seed and source.

#### How is this different from People Also Ask scrapers?

PAA scrapers need a full search results page per query, which is slow and usually needs a proxy.
Question expansion here queries the autocomplete endpoint directly with `how`, `why`, `what` … in
front of the seed, so you get real question keywords in seconds with no proxy.

#### Does it work with n8n, Make and Google Sheets?

Yes. The output is flat rows, so any Apify integration can push it to a sheet, a database or a
Slack message with no transformation step.

#### Will one source being down break the keyword research scraper run?

No. Every source and seed pair is isolated. If Amazon times out, the Google, YouTube and Bing rows
are still delivered, and the Amazon pair gets one explanatory row instead of silently vanishing.

# Actor input Schema

## `seedKeywords` (type: `array`):

One keyword or phrase per line. Each seed is sent to every selected source and expanded with the modifiers you choose below.

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

Which autocomplete engines to query. Each source is isolated: if one is down the others still deliver.

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

Two-letter language code, e.g. en, de, es, sv, fr. Used by Google, YouTube, Bing and DuckDuckGo. Amazon, App Store and eBay follow the country instead.

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

Two-letter country code, e.g. us, gb, de, fr, se, jp, in, au, ca, br. Picks the Google/Bing/DuckDuckGo region, the Amazon marketplace, the App Store storefront and the eBay site. Unsupported Amazon/App Store/eBay countries fall back to the US with a warning in the log.

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

Prepend who, what, why, how, when, where, which, can, does, is, are, should, will to each seed (13 extra queries per seed and source). Finds the questions people actually type - a free People Also Ask alternative.

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

Append for, with, without, near, to, like, vs, versus, and, or to each seed (10 extra queries per seed and source). Surfaces comparison and intent keywords.

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

Append a space and every letter a to z to each seed (26 extra queries per seed and source). This is the classic alphabet soup method and is where most long-tail keywords come from.

## `expandDigits` (type: `boolean`):

Append 0 to 9 to each seed (10 extra queries per seed and source). Useful for products, years and versions such as 'iphone 17' or 'best laptops 2026'.

## `depth` (type: `integer`):

1 = expand only the seeds. 2 = also send every keyword found at level 1 back to the same source as a new query, until 'Maximum keywords per seed' is reached. Depth 2 multiplies results roughly 5-10x.

## `maxKeywordsPerSeed` (type: `integer`):

Cap per seed and source. Caps the level-2 crawl and therefore your cost.

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

Optional. None of the sources need a proxy at normal volumes; switch one on only if you run very large depth-2 jobs and see rate limits in the log.

## Actor input object example

```json
{
  "seedKeywords": [
    "ai tools"
  ],
  "sources": [
    "google",
    "youtube",
    "bing",
    "amazon",
    "appstore",
    "duckduckgo"
  ],
  "language": "en",
  "country": "us",
  "expandQuestions": true,
  "expandPrepositions": false,
  "expandAlphabet": false,
  "expandDigits": false,
  "depth": 1,
  "maxKeywordsPerSeed": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `keywords` (type: `string`):

Every keyword with its source, seed, modifier, position and relevance.

## `keywordsCsv` (type: `string`):

The same records as a spreadsheet-ready CSV file.

## `consoleView` (type: `string`):

Open the run's dataset in Apify Console.

# 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 = {
    "seedKeywords": [
        "ai tools"
    ],
    "sources": [
        "google",
        "youtube",
        "bing",
        "amazon",
        "appstore",
        "duckduckgo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nourishing_courier/keyword-research-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 = {
    "seedKeywords": ["ai tools"],
    "sources": [
        "google",
        "youtube",
        "bing",
        "amazon",
        "appstore",
        "duckduckgo",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("nourishing_courier/keyword-research-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 '{
  "seedKeywords": [
    "ai tools"
  ],
  "sources": [
    "google",
    "youtube",
    "bing",
    "amazon",
    "appstore",
    "duckduckgo"
  ]
}' |
apify call nourishing_courier/keyword-research-scraper --silent --output-dataset

```

## MCP server setup

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