# YouTube Keyword Suggestions Scraper (No Key) (`ninhothedev/youtube-keyword-scraper`) Actor

Get localized YouTube autocomplete keyword suggestions with optional Latin A-Z expansion. No API key. Bounded results for content ideas; no search-volume estimates.

- **URL**: https://apify.com/ninhothedev/youtube-keyword-scraper.md
- **Developed by:** [ninhothedev](https://apify.com/ninhothedev) (community)
- **Categories:** SEO tools, Videos, Social media
- **Features:** Limited permissions
- **Stats:** 30 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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?

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

## YouTube Keyword Suggestions Scraper

Get localized YouTube autocomplete suggestions without an API key. Suggestions are **not measured search volumes, competition scores, extracted video tags, or guaranteed rankings**. Coverage varies by locale and time and is not exhaustive.

### Quick start

```json
{"keywords":["minecraft"],"language":"en","country":"US","alphabetExpansion":false,"maxItems":5}
```

An empty API object uses these same defaults. Existing API input with a single keyword string remains supported. Up to 50 seeds of 1–200 characters are accepted. Invalid types, blank seeds, unsupported modes and invalid locale syntax fail before requests. Language accepts codes such as `en`, `ja`, `zh-TW`; country accepts two-letter codes such as `US`, `JP`. The endpoint determines locale support.

### Inputs and limits

- `mode`: `suggest` only.
- `keywords`: case-insensitive repeated seeds are processed once.
- `language` / `country`: defaults `en` / `US`.
- `alphabetExpansion`: default false; true also requests seed plus Latin letters a–z, even for non-Latin seeds.
- `maxItems`: integer 1–5000, default 5; global across all seeds and expansions, including existing rows on resurrection.

Default change: previously omitted expansion/limit meant true/500. Specify those values explicitly to retain that breadth. Processing checks charging and result capacity before each request and write. Each HTTP attempt times out after 15 seconds. Transport and HTTP failures are retried up to three attempts with short backoff; malformed successful responses are not retried. Larger inputs require an appropriate overall run timeout. A small limit can stop before later seeds.

### Output

Each row is one unique `(keyword, seed)` association, case-insensitive and Unicode-normalized. The same keyword under different seeds remains multiple results, preserving the existing contract. First occurrence wins across expansions. Existing fields remain: `keyword`, `seed`, `language`, `country`, `rank`, `source`, `scraped_at`. Added fields are stable `id`, exact `query`, and `source_url`. Rank is the 1-based position in that query's suggestion response, not search rank or popularity.

Illustrative output, not a current capture:

```json
{"keyword":"minecraft survival","seed":"minecraft","language":"en","country":"US","rank":2,"source":"youtube","scraped_at":"2026-09-05T12:00:00+00:00","query":"minecraft","id":"<SHA-256 of keyword, seed and locale>","source_url":"https://suggestqueries-clients6.youtube.com/complete/search?client=youtube&ds=yt&q=minecraft&hl=en&gl=US"}
```

Export the dataset as JSON or CSV. Existing dataset rows, including old-format rows, are the delivery journal on resurrection. Already delivered associations are not pushed/charged again in normal resurrection. Keep inputs unchanged on resurrection; use a new run for a fresh snapshot. A crash between platform storage and billing is not an application-level transactional guarantee.

### Failures and coverage

A valid empty response succeeds with zero result events. Failed queries are recorded and processing continues for other queries. If any query fails and no rows are available, the run fails; otherwise delivered partial rows remain available. Error records are not billable rows. `RUN_SUMMARY` in key-value storage records `complete`, `limit_reached`, `partial`, or `source_error`, row count, and the number of attempted queries for this invocation (not individual HTTP retry attempts). `failedQueries` and `partial` preserve source failures even when a later result or cost limit stops the run; `stop_reason` records the stopping condition. Complete means all requested queries were processed, not exhaustive YouTube coverage. Previously empty requests may repeat after resurrection.

No API key, proxy, browser fallback or paid third-party service is required. Public endpoints may change or block requests. Report reproducible input and run ID through the Actor issue channel without private data.

### Pricing

Existing prices are unchanged: $0.0005 per delivered keyword-plus-seed result and the listed start event of $0.00005 per GB. The start event has a 1 GB minimum, so at 512 MB the start component is $0.00005. Illustrative event totals: 5 results $0.00255; 500 results $0.25005; 30 separate 50-result runs $0.7515. Actual pricing depends on current Console configuration and tier. These are event calculations, not measured infrastructure costs or margin guarantees. No result charging capacity means no further source work; infrastructure can still consume resources during a timeout.

### Turn suggestions into a video research shortlist

1. Start with one seed relevant to your audience, such as `Shopify`, with expansion off and a small global limit. Add seeds in separate runs when you need comparable coverage; a shared limit can leave later seeds unqueried.
2. Export suggestions with their seed, locale and exact query. Filter for topics your customers actually ask about. Autocomplete alone does not measure demand or revenue potential.
3. Paste selected suggestions into the `queries` input of [YouTube Search Scraper](https://apify.com/ninhothedev/youtube-search-scraper) to inspect matching videos, channels and public view counts. Its per-query coverage summary helps identify missing results.
4. For repeat research, keep the seed, locale and limits fixed and check `RUN_SUMMARY` before comparing snapshots. A missing suggestion can reflect a bounded response or changed autocomplete, rather than declining demand.

The two Actors run separately and each has its own pricing. This Actor does not automatically start or charge for video searches.

# Actor input Schema

## `mode` (type: `string`):

Scraping mode. 'suggest' expands each seed keyword into YouTube autocomplete suggestions (optionally with A-Z expansion).

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

Seed phrases for YouTube autocomplete suggestions. These are not extracted video tags or measured search volumes.

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

Interface / suggestion language code (YouTube 'hl' parameter), e.g. 'en', 'de', 'es', 'fr'.

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

Two-letter country code for localized suggestions (YouTube 'gl' parameter), e.g. 'US', 'GB', 'DE'.

## `alphabetExpansion` (type: `boolean`):

Also query each seed followed by Latin letters a–z. The global limit may stop before later queries or seeds.

## `maxItems` (type: `integer`):

Global maximum of unique keyword + seed pairs, including existing rows when resumed. The same keyword may appear for different seeds.

## Actor input object example

```json
{
  "mode": "suggest",
  "keywords": [
    "minecraft"
  ],
  "language": "en",
  "country": "US",
  "alphabetExpansion": false,
  "maxItems": 5
}
```

# 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 = {
    "keywords": [
        "minecraft"
    ]
};

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

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

```

## MCP server setup

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