# YouTube Niche Scout (`kuromaro/youtube-niche-scout`) Actor

Analyze YouTube search results to find profitable, low-competition niches for content creators. Get engagement rates, niche scores, and views-per-subscriber metrics.

- **URL**: https://apify.com/kuromaro/youtube-niche-scout.md
- **Developed by:** [Takuma](https://apify.com/kuromaro) (community)
- **Categories:** Social media, Videos
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $300.00 / 1,000 keyword analyzeds

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 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 Niche Scout

Analyze YouTube search results to discover profitable content niches.
For each keyword, the actor fetches the top videos, scores them by demand vs.
competition, and returns enriched data you can use to make data-driven decisions
about what content to create.

### Features

- **Niche opportunity score** — balances average view count against the number of
  competing videos. A high score means high demand with low supply.
- **Engagement rate** — `(likeCount + commentCount) / viewCount` per video.
- **Views per subscriber** — measures how well a video outperforms its channel audience.
- **YouTube Data API v3 support** — accurate view counts, subscriber counts, like/comment
  data for up to 200 results per run.
- **yt-dlp fallback** — works without an API key (up to 50 results, limited metadata).
- **Multi-language support** — bias results toward EN, JA, ES, FR, DE, PT, KO, or ZH.
- **Date filtering** — restrict results to videos published after a given date.
- **Sort options** — by relevance, view count, or upload date.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keyword` | string | Yes | — | Topic to analyze (e.g. `home workout beginners`) |
| `youtubeApiKey` | string | No | — | Google Cloud API key (YouTube Data API v3). Omit to use yt-dlp. |
| `maxResults` | integer | No | `50` | Videos to analyze (max 200 with API, 50 with yt-dlp) |
| `publishedAfter` | string | No | — | ISO date filter, e.g. `2026-01-01` |
| `sortBy` | enum | No | `relevance` | `relevance` / `viewCount` / `date` |
| `language` | enum | No | `en` | Relevance language code |
| `proxyConfiguration` | object | No | — | Apify Proxy settings |

#### Example input

```json
{
  "keyword": "sourdough bread for beginners",
  "youtubeApiKey": "YOUR_GOOGLE_API_KEY",
  "maxResults": 50,
  "publishedAfter": "2025-01-01",
  "sortBy": "viewCount",
  "language": "en"
}
```

### Output

Each item in the dataset represents one video:

```json
{
  "videoId": "dQw4w9WgXcQ",
  "title": "Sourdough Bread for Beginners (Full Tutorial)",
  "channelName": "BreadBakers",
  "channelId": "UCxxxxxx",
  "publishedAt": "2025-03-15T10:00:00Z",
  "duration": 1245,
  "viewCount": 850000,
  "likeCount": 42000,
  "commentCount": 3100,
  "channelSubscribers": 120000,
  "engagementRate": 0.053,
  "viewsPerSubscriber": 7.08,
  "nicheScore": 28333.3,
  "keyword": "sourdough bread for beginners",
  "searchRank": 1
}
```

#### Field descriptions

| Field | Description |
|---|---|
| `videoId` | YouTube video ID |
| `title` | Video title |
| `channelName` | Channel name |
| `channelId` | YouTube channel ID |
| `publishedAt` | ISO 8601 publish date |
| `duration` | Video length in seconds |
| `viewCount` | Total view count |
| `likeCount` | Total like count |
| `commentCount` | Total comment count |
| `channelSubscribers` | Channel subscriber count (0 when using yt-dlp fallback) |
| `engagementRate` | `(likeCount + commentCount) / viewCount` |
| `viewsPerSubscriber` | `viewCount / channelSubscribers` |
| `nicheScore` | `avgViews / videoCount` — higher = better niche opportunity |
| `keyword` | The keyword that produced this result |
| `searchRank` | Position in the search results (1-indexed) |

### How the niche score works

```
nicheScore = (average viewCount across all results) / (number of results)
```

A niche with 3 results averaging 500 000 views each scores **much** higher than one
with 50 results averaging 10 000 views — because it has high audience demand and low
creator competition.

Use `nicheScore` to compare keywords head-to-head.

### Getting a YouTube Data API key

1. Go to [Google Cloud Console](https://console.cloud.google.com/).
2. Create a project and enable **YouTube Data API v3**.
3. Generate an API key under **Credentials**.
4. Paste the key into the `youtubeApiKey` field.

The free quota is **10 000 units/day**. Each run uses roughly 3–5 units per video
(search + video details + channel stats).

### Use cases

- Identify underserved YouTube niches before creating a channel.
- Benchmark competitor engagement rates for any keyword.
- Find trending topics by filtering `publishedAfter` to recent months.
- Build keyword research pipelines by running the actor on many keywords in sequence.

### Pricing

This actor uses **pay-per-event** billing. You are charged **1 event per keyword analyzed**
(regardless of how many videos are returned).

# Actor input Schema

## `keyword` (type: `string`):

The topic or keyword to analyze on YouTube (e.g. 'home workout for beginners').

## `youtubeApiKey` (type: `string`):

Google Cloud API key with YouTube Data API v3 enabled. If omitted, yt-dlp fallback is used (fewer results, no subscriber data).

## `maxResults` (type: `integer`):

Maximum number of videos to analyze. API mode supports up to 200; yt-dlp fallback is capped at 50.

## `publishedAfter` (type: `string`):

Only return videos published after this date. Format: YYYY-MM-DD or RFC 3339 (e.g. 2026-01-01).

## `sortBy` (type: `string`):

How to order search results.

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

Language code to bias search results toward.

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

Optional Apify Proxy configuration for requests.

## Actor input object example

```json
{
  "maxResults": 50,
  "publishedAfter": "2026-01-01",
  "sortBy": "relevance",
  "language": "en"
}
```

# 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 = {
    "publishedAfter": "2026-01-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kuromaro/youtube-niche-scout").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 = { "publishedAfter": "2026-01-01" }

# Run the Actor and wait for it to finish
run = client.actor("kuromaro/youtube-niche-scout").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 '{
  "publishedAfter": "2026-01-01"
}' |
apify call kuromaro/youtube-niche-scout --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yoHjkIKa8LfygAqx1/builds/wpuCiAUlYni063k2C/openapi.json