# Youtube Keywords Discovery Tool (`maximedupre/youtube-keywords-discovery-tool`) Actor

Discover YouTube autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, query variants, and duplicate-query evidence to CSV, JSON, Excel, API, or integrations.

- **URL**: https://apify.com/maximedupre/youtube-keywords-discovery-tool.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.65 / 1,000 found suggestions

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 keywords discovery tool for autocomplete suggestions

Youtube Keywords Discovery Tool collects autocomplete keyword suggestions from [YouTube](https://www.youtube.com/) search. Add one or more seed terms such as `ai tools`, `home workout`, or `travel vlog`, then export source-ranked Youtube keyword suggestions with the original seed, the exact query variant, and duplicate-query evidence.

Use this Actor for Youtube keyword research, content planning, video SEO briefs, niche research, campaign ideation, and repeatable keyword exports. It turns manual Youtube search-box checks into a structured Apify dataset you can download as JSON, CSV, Excel, XML, RSS, or HTML, or send to an API, webhook, scheduler, or integration.

For a first run, keep the prefilled seeds and default limit. They produce a broad sample across common Youtube research topics while staying bounded.

### ✅ What this Actor does

- Searches Youtube autocomplete with one or more seed keywords.
- Saves one dataset item per keyword suggestion.
- Checks base, question-style, preposition-style, and alphabetic query variants.
- Keeps Youtube's source order for each query variant.
- Deduplicates repeated suggestions within each seed keyword.
- Preserves the query variants that produced the same suggestion.
- Adds the original seed keyword and source rank to every row.
- Stops at your per-seed suggestion limit.
- Runs without Youtube login, cookies, OAuth, or a user-provided API key.

This Actor is focused on Youtube search autocomplete suggestions. It does not scrape Youtube videos, channels, comments, tags, transcripts, search volume, keyword difficulty, or trend scores.

### 📦 Data you can extract

Each output item represents one Youtube autocomplete suggestion. Fields include:

- `seedKeyword`
- `query`
- `suggestion`
- `sourceRank`
- `duplicateSourceQueries`

`sourceRank` is the one-based order returned by the source for the query variant. `duplicateSourceQueries` helps you see when the same suggestion appeared from more than one variant, without paying for duplicate rows within the same seed keyword.

### 🚀 Common use cases

- Build Youtube keyword research exports for video planning.
- Find autocomplete phrases around a product, niche, creator topic, or audience problem.
- Compare Youtube keyword suggestions across several seed terms.
- Create content calendars from phrases people may type into Youtube search.
- Feed Youtube keyword suggestions into spreadsheets, dashboards, or AI workflows.
- Schedule repeat checks for the same keyword set.
- Collect clean source-ranked suggestions for social search and Youtube SEO research.

### ▶️ How to run it

1. Add one or more seed keywords in **Seed keywords**.
2. Keep **Suggestions per seed** at `500` for a broad first run.
3. Start the Actor and open the dataset.

For larger jobs, add several related seeds and adjust the per-seed limit to control output size and spend.

### 🛠️ Input

#### 🧪 Example input

```json
{
	"keywords": [
		"ai tools",
		"home workout",
		"travel vlog",
		"cooking tips",
		"productivity apps",
		"study music"
	],
	"maxSuggestionsPerKeyword": 500
}
````

#### 🎯 Seed keywords

Enter plain Youtube search seeds. Good examples:

- `ai tools`
- `home workout`
- `travel vlog`
- `cooking tips`
- `productivity apps`

Each seed is queried separately. Empty seed values are ignored during normalization.

#### 📏 Suggestions per seed

Use `maxSuggestionsPerKeyword` to control how many suggestions can be saved for each seed keyword. The default and maximum are `500` per seed.

### 📊 Output example

```json
{
	"seedKeyword": "ai tools",
	"query": "ai tools a",
	"suggestion": "ai tools for youtube creators",
	"sourceRank": 1,
	"duplicateSourceQueries": ["ai tools", "ai tools a"]
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each Youtube keyword suggestion that is found and saved. Runs that find fewer suggestions only charge for the saved suggestions.

### ⚠️ Limits and caveats

- Youtube autocomplete suggestions can change over time.
- Some seeds can return fewer suggestions than your requested limit.
- The Actor does not provide search volume, CPC, popularity scores, keyword difficulty, or trend predictions.
- The Actor does not localize by country or language.
- Youtube may temporarily return fewer suggestions or no suggestions for a seed.

### ❓ FAQ

#### 🔐 Does this use the official Youtube API?

No. It collects public Youtube autocomplete suggestions shown by Youtube search. You do not need to provide a Youtube account, cookies, OAuth, or API key.

#### 🎬 Can it scrape Youtube videos or channels?

No. This Actor is only for Youtube keyword suggestions. Use a Youtube video, channel, transcript, or comments scraper when you need content rows instead of keyword ideas.

#### 📈 Does it return search volume?

No. The output contains suggestions and source order, not search-volume or popularity metrics. This avoids inventing metrics that Youtube does not expose through this search surface.

#### 🧺 Can I run many keywords at once?

Yes. Add multiple seed keywords and use the per-seed limit to control the run size.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~youtube-keywords-discovery-tool/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Channel Search Scraper ↗](https://apify.com/maximedupre/youtube-channel-search-scraper) - Find public YouTube channels from search keywords.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public YouTube channel profiles and recent video rows.
- [YouTube Channel Statistics Scraper ↗](https://apify.com/maximedupre/youtube-channel-statistics-scraper) - Collect public statistics for YouTube channels.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete suggestions from seed keywords.
- [Quora Search Scraper ↗](https://apify.com/maximedupre/quora-search-scraper) - Find public Quora question pages from search terms or direct URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter one or more Youtube search seeds. Each seed is checked separately.

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

Maximum Youtube autocomplete suggestions to save for each seed keyword.

## Actor input object example

```json
{
  "keywords": [
    "ai tools",
    "home workout",
    "travel vlog",
    "cooking tips",
    "productivity apps",
    "study music"
  ],
  "maxSuggestionsPerKeyword": 500
}
```

# Actor output Schema

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

Open the dataset with one item per YouTube autocomplete suggestion.

# 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": [
        "ai tools",
        "home workout",
        "travel vlog",
        "cooking tips",
        "productivity apps",
        "study music"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/youtube-keywords-discovery-tool").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": [
        "ai tools",
        "home workout",
        "travel vlog",
        "cooking tips",
        "productivity apps",
        "study music",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/youtube-keywords-discovery-tool").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "ai tools",
    "home workout",
    "travel vlog",
    "cooking tips",
    "productivity apps",
    "study music"
  ]
}' |
apify call maximedupre/youtube-keywords-discovery-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/youtube-keywords-discovery-tool",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Keywords Discovery Tool",
        "description": "Discover YouTube autocomplete keyword suggestions from seed terms. Export source-ranked suggestions, query variants, and duplicate-query evidence to CSV, JSON, Excel, API, or integrations.",
        "version": "0.1",
        "x-build-id": "fBHl2gB4f4WNY2qTy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~youtube-keywords-discovery-tool/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-youtube-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-keywords-discovery-tool/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-youtube-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~youtube-keywords-discovery-tool/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-youtube-keywords-discovery-tool",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Enter one or more Youtube search seeds. Each seed is checked separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxSuggestionsPerKeyword": {
                        "title": "Suggestions per seed",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum Youtube autocomplete suggestions to save for each seed keyword.",
                        "default": 500
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```