# YouTube Autocomplete Keyword Scraper: a-z, questions, CSV/JSON (`tallyrake/youtube-autocomplete-scraper`) Actor

YouTube search suggestions as CSV/JSON rows at $0.25 per 1,000 dataset rows: seed, query sent, suggestion, rank, expansion (a-z, question words, prepositions; comparisons and numbers optional), language, country, stable id.

- **URL**: https://apify.com/tallyrake/youtube-autocomplete-scraper.md
- **Developed by:** [Tallyrake Data](https://apify.com/tallyrake) (community)
- **Categories:** SEO tools, Marketing, Videos
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.25 / 1,000 results

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?

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

## YouTube Autocomplete Keyword Scraper: a-z, questions, CSV/JSON

YouTube autocomplete as CSV/JSON rows. Give it seed keywords; it requests suggestions for the seed, seed + a to z, question words, and prepositions (comparisons and numbers only if you enable those expansions), for the language you set. One flat row per unique suggestion per seed, each with a stable `id`. $0.25 per 1,000 dataset rows.

### What you get

| Field | Example |
|---|---|
| `id` | stable per seed, language, query and suggestion |
| `keyword` | `coffee grinder` (your seed) |
| `query` | `coffee grinder b` (the exact string sent) |
| `suggestion` | `coffee grinder burr` |
| `rank` | `1` (position in the engine's list for that query) |
| `expansion` | `direct`, `alphabet`, `question`, `preposition`, `comparison`, `number`, `depth` |
| `modifier` | `b`, `how`, `for`, `vs` |
| `depth` | `1` or `2` |
| `language`, `country` | `en`, `us` |
| `engine` | `youtube` |
| `fetchedAt` | ISO timestamp |

Rows are deduplicated per seed (case-insensitive), so a suggestion that appears under several modifiers is counted once, under the first query that produced it.

### Where this sits on the shelf

Apify Store search for "youtube autocomplete", top 10 results on 2026-09-11, read from the Store API. Price is the pay-per-event charge per dataset item, converted to per 1,000 rows; users, runs and the failed-or-timed-out share are the Store's 30-day public stats for each listing.

| Listing | Users (30d) | Runs (30d) | Failed or timed out | Price per 1,000 rows |
|---|---|---|---|---|
| sian.agency/youtube-auto-complete-and-query-suggestion | 13 | 64 | 3% | $5.00 |
| johnatan029/keyword-trend-monitor | 1 | 15 | 0% | $0.05 |
| maged120/youtube-music-autocomplete | 0 | 29 | 0% | free |
| aitorsm/keyword-fanout | 17 | 68 | 0% | $0.05 |
| lofomachines/keyword-shitter-autocomplete-scraper | 0 | 31 | 0% | free |
| karamelo/youtube-keywords-shitter | 10 | 96 | 0% | free |
| solidcode/youtube-keyword-scraper | 4 | 37 | 0% | free |
| ninhothedev/youtube-keyword-scraper | 4 | 72 | 0% | $0.50 |
| maximedupre/youtube-keywords-discovery-tool | 3 | 63 | 0% | $2.65 |
| scrapemint/google-keyword-suggestions-scraper | 2 | 43 | 0% | $1.00 |
| tallyrake/youtube-autocomplete-scraper (this actor) | 0 | 1 | 0 of 1 | $0.25 |

### Recipes

**Content brief for one topic.** Seeds: your topic. Expansions: questions, prepositions. Depth 1. Output: the questions and phrasings YouTube suggests for the topic, each with the engine rank on the query that first produced it (dedup keeps the first hit, not a single global order).

**Keyword list for a niche.** Seeds: 10 to 50 head terms. Expansions: alphabet. Depth 2. YouTube returns at most 10 suggestions per query, and `maxQueriesPerKeyword` (default 300) caps the requests per seed, so one seed can produce at most 3,000 dataset rows before dedup (at most $0.75 at $0.25 per 1,000). You are billed unique dataset rows, not queries; empty queries bill $0. For 10 to 50 seeds there is no measured run yet; start at concurrency 3 without a proxy and turn on Apify Proxy only if the log shows 429 or 403 responses.

**Localized suggestions.** Same seeds, `language` set per run. Rows carry the code so runs can be merged.

**Brand and competitor monitoring.** Seeds: brand names. Expansions: comparisons, questions. Schedule daily. Diff the `suggestion` column between runs.

### Input

Paste seeds one per line. The default expansions send 52 queries per seed (1 seed + 26 letters + 14 question words + 11 prepositions = 52). Comparisons and numbers are not in that 52; they are extra expansions. One seed is not one billable unit: see the measured yield below for what 52 queries produced.

### Reliability and cost

Measured on 2026-09-11 on Apify: 2 seeds (`coffee grinder`, `pytrends 429`), expansions alphabet + questions + prepositions (52 queries per seed), concurrency 3, no proxy, `en`/`us`: 104 queries produced 333 dataset rows (about 3.2 per query), 0 rate-limited responses, 13 seconds. That run bills $0.08 in results (333 rows at $0.25 per 1,000) plus $0.0020 of platform compute. Per seed in that run: `coffee grinder` 323 rows ($0.081), `pytrends 429` 10 rows ($0.003).

Pay per event: $0.25 per 1,000 dataset rows, plus Apify platform usage for the run. Empty queries produce no rows and no results charge. Every request is paced with a jittered delay (`pacingMs`, default 200 ms). If the engine answers 429 or 403, the run rotates its session and retries; that path was not exercised in the measured run.

### Cost limit

If a run reaches the "Maximum total charge per run" you set, it stops in process rather than being aborted by the platform: the run ends with status SUCCEEDED, and the run status message on the run detail says how many rows were written and how many were found but not written and not billed. Re-running the same input writes and bills the same prefix again, so raise the cap before re-running if you want the rest. Measured on this actor on 2026-09-14: a $0.01 cap on a three-seed, all-expansions, depth-2 input wrote 40 rows (40 x $0.25 / 1,000 = $0.01) and reported 1,222 found but not written; a $0.05 cap on the one-seed default input (`coffee grinder`, 52 queries) wrote 200 rows ($0.05) and reported 123 found but not written.

### Limits

This is YouTube's suggestion list for the language you set, at the time of the run. It carries no search volume; pair it with a Google Trends actor for demand. YouTube returns at most 10 suggestions per query. Export CSV for Excel and Google Sheets. Export JSON for pipelines.

# Actor input Schema

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

One seed per line. Each seed is expanded (see Expansions) and every expanded query is sent to Google Autocomplete.

## `expansions` (type: `array`):

How to fan each seed out. alphabet: seed + a..z (26 queries). questions: who/what/why/how/when/where/which/is/are/can/does/do/will/should + seed (14). prepositions: seed + for/with/without/to/near/in/on/from/like/after/before (11). comparisons: seed + vs/or/versus/and (4). numbers: seed + 1..5/10/2026 (7). The plain seed is always queried.

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

1 = expand the seeds only. 2 = also send every first-level suggestion back to Autocomplete (capped by Max queries per keyword).

## `maxQueriesPerKeyword` (type: `integer`):

Cap on the number of Autocomplete requests made per seed, across expansions and depth.

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

Interface language code, e.g. en, de, es, pt, ja.

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

Two-letter country code that localises the suggestions, e.g. us, gb, de, in, br.

## `dedupe` (type: `boolean`):

Keep the first occurrence of each suggestion per seed keyword (case-insensitive).

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

Off by default; the Autocomplete endpoint tolerates a few hundred paced requests from one address. Turn Apify Proxy on for large keyword lists or if you see rate limiting in the log.

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

Parallel Autocomplete requests. 3 is safe without a proxy; up to 10 with Apify Proxy.

## `pacingMs` (type: `integer`):

Base jittered delay between requests per worker; 0 disables pacing.

## Actor input object example

```json
{
  "keywords": [
    "coffee grinder"
  ],
  "expansions": [
    "alphabet",
    "questions",
    "prepositions"
  ],
  "depth": 1,
  "maxQueriesPerKeyword": 300,
  "language": "en",
  "country": "us",
  "dedupe": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxConcurrency": 3,
  "pacingMs": 200
}
```

# Actor output Schema

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

All suggestion rows (one per suggestion per seed).

## `csv` (type: `string`):

The same rows as CSV.

# 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": [
        "coffee grinder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tallyrake/youtube-autocomplete-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": ["coffee grinder"] }

# Run the Actor and wait for it to finish
run = client.actor("tallyrake/youtube-autocomplete-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": [
    "coffee grinder"
  ]
}' |
apify call tallyrake/youtube-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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