# YouTube Channel Finder — Niche Creator Discovery (`northglasslabs/youtube-channel-database-search`) Actor

Find YouTube channels by niche keyword and subscriber range. Export public channel titles, URLs, descriptions, subscriber counts, video counts, and view counts for creator research.

- **URL**: https://apify.com/northglasslabs/youtube-channel-database-search.md
- **Developed by:** [North Glass Labs](https://apify.com/northglasslabs) (community)
- **Categories:** Social media, Videos
- **Stats:** 9 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.34 / 1,000 result storeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Channel Database Search — Find Creators by Niche

Turn a niche keyword into a structured list of YouTube channels. Use subscriber-range filters to narrow the results for **niche creator discovery**, **sponsorship research**, **podcast guest discovery**, or **creator lead lists**.

The Actor searches YouTube's channel-filtered results, scrolls for more channel cards, removes duplicates, applies filters when subscriber counts are visible, and enriches each result from its public About page.

### What you can do with it

- **Discover niche creators** — search a specific topic such as `indie game development`, `climate technology`, or `home coffee roasting`.
- **Research sponsorship candidates** — compare visible audience size, publishing volume, descriptions, and channel links before doing your own fit review.
- **Find possible podcast guests** — build a research shortlist of creators with relevant channel descriptions and public profiles.
- **Build creator lead lists** — export channel metadata to JSON, CSV, Excel, or another workflow for qualification.

This Actor returns channel metadata, not a guaranteed contact database. An `email` is included only **when publicly visible** in the rendered About-page text. It does not bypass YouTube's business-email reveal flow, authentication, CAPTCHA, or other access controls, and many records will not contain an email.

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---:|---|
| `searchQuery` | string | Yes | — | Niche keyword or phrase used in YouTube channel search. |
| `maxResults` | integer | No | `50` | Maximum channels to return, from 1 to 500. YouTube may expose fewer. |
| `minSubscribers` | integer | No | `0` | Minimum visible subscriber count. `0` disables the lower bound. |
| `maxSubscribers` | integer | No | `0` | Maximum visible subscriber count. `0` disables the upper bound. |

Subscriber filters only apply when YouTube exposes a parseable count. Channels with hidden or unavailable counts are retained rather than treated as zero.

#### Example input

```json
{
  "searchQuery": "climate technology podcast",
  "maxResults": 25,
  "minSubscribers": 5000,
  "maxSubscribers": 250000
}
```

### Output

The default dataset contains one object per channel. Fields derived from search cards are normally present; About-page enrichment fields can be omitted when YouTube does not expose them or the page cannot be loaded.

| Field | Type | Meaning |
|---|---|---|
| `channelId` | string | YouTube channel ID when exposed. |
| `channelName` | string | Channel display name. |
| `channelUrl` | string | Canonical or rendered channel URL. |
| `handle` | string | Public `@handle` when exposed. |
| `subscriberCount` | integer | Parsed count; `0` can also mean hidden or unavailable, so check `subscriberText`. |
| `subscriberText` | string | Subscriber text exposed by YouTube. |
| `videoCount` | integer | Parsed video count when available. |
| `description` | string | Search snippet or About-page description. |
| `imageUrl` | string | Channel thumbnail URL when available. |
| `totalViews` | integer | Parsed aggregate view count when available. |
| `email` | string | Email found in already-visible public About-page text, when available. |
| `country` | string | Channel-declared country when available. |
| `joinedDate` | string | Joined-date text when available. |

Illustrative record (values and optional-field availability vary by channel):

```json
{
  "channelId": "UCexample123",
  "channelName": "Example Climate Channel",
  "channelUrl": "https://www.youtube.com/@exampleclimate",
  "handle": "@exampleclimate",
  "subscriberCount": 84200,
  "subscriberText": "84.2K subscribers",
  "videoCount": 412,
  "description": "Interviews and explainers about climate technology.",
  "imageUrl": "https://yt3.googleusercontent.com/example",
  "totalViews": 5230000,
  "country": "United States",
  "joinedDate": "Joined Mar 15, 2018"
}
```

### API and automation recipes

Set an Apify API token first:

```bash
export APIFY_TOKEN="your_apify_token"
```

The synchronous endpoint in the cURL and n8n examples waits for the run and returns dataset items directly. Keep `maxResults` modest for synchronous workflows because the Actor visits each selected channel's About page.

#### cURL

```bash
curl --request POST \
  "https://api.apify.com/v2/acts/northglasslabs~youtube-channel-database-search/run-sync-get-dataset-items?token=${APIFY_TOKEN}&format=json&clean=true" \
  --header "Content-Type: application/json" \
  --data '{
    "searchQuery": "climate technology podcast",
    "maxResults": 25,
    "minSubscribers": 5000,
    "maxSubscribers": 250000
  }'
```

#### Python

Install the client with `pip install apify-client`, then:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("northglasslabs/youtube-channel-database-search").call(
    run_input={
        "searchQuery": "climate technology podcast",
        "maxResults": 25,
        "minSubscribers": 5000,
        "maxSubscribers": 250000,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items(clean=True).items
print(items)
```

#### JavaScript

Install the client with `npm install apify-client`, then:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('northglasslabs/youtube-channel-database-search').call({
  searchQuery: 'climate technology podcast',
  maxResults: 25,
  minSubscribers: 5000,
  maxSubscribers: 250000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items);
```

#### n8n / HTTP Request

Create an **HTTP Request** node with:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/northglasslabs~youtube-channel-database-search/run-sync-get-dataset-items`
- **Query parameters:** `token` = your Apify token, `format` = `json`, `clean` = `true`
- **Send Body:** on
- **Body Content Type:** JSON
- **JSON Body:**

```json
{
  "searchQuery": "climate technology podcast",
  "maxResults": 25,
  "minSubscribers": 5000,
  "maxSubscribers": 250000
}
```

For production n8n workflows, store the token in an n8n credential or secret rather than directly in the node. The response is the array of dataset records and can feed a Filter, Google Sheets, Airtable, database, or CRM qualification step.

### Pricing

The public Actor configuration checked on **July 30, 2026** lists pay-per-event pricing of:

- **$0.02** for the Actor Start event.
- **$0.00275 per returned dataset item** on the Free tier (**$2.75 per 1,000 results**), with lower per-item prices configured for paid Apify tiers.

For example, 50 returned items correspond to a listed event subtotal of **$0.15750** before tier discounts. Your total can also include Apify platform usage, and a run can return fewer than `maxResults`; check the live Actor pricing panel before running because pricing can change.

### How it works

1. Opens YouTube search with the channel-only filter.
2. Parses embedded `ytInitialData` and rendered channel cards.
3. Scrolls until the requested unique count is reached, growth stalls, or the scroll limit is reached.
4. Deduplicates by available channel ID, handle, and URL.
5. Applies subscriber bounds only to channels with visible, parseable counts.
6. Visits each selected channel's public `/about` page and adds details that are available.
7. Pushes one channel object to the default Apify dataset.

### Limits and data interpretation

- YouTube is JavaScript-rendered and can cap, vary, or block results. The implementation retries direct access first and then configured proxy sessions, but a requested count is not guaranteed.
- Search order comes from YouTube. This Actor does not calculate sponsorship fit, engagement rate, audience demographics, or guest suitability.
- `subscriberCount: 0` is ambiguous when `subscriberText` is empty or says the count is hidden.
- `totalViews`, `country`, `joinedDate`, and `email` depend on the public About page and may be absent.
- A public email, when found, has not been validated for deliverability or permission to contact. Qualify leads and follow applicable outreach and privacy rules.
- For workloads requiring official API guarantees, evaluate the [YouTube Data API v3](https://developers.google.com/youtube/v3).

### Local verification

```bash
python3 -m pip install -r requirements.txt pytest
python3 -m pytest -q
apify validate-schema
apify run
```

Local test input lives at `storage/key_value_stores/default/INPUT.json` when running with Apify local storage.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword or phrase for YouTube channel search, such as 'climate technology podcast' or 'home coffee roasting'.

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

Maximum number of unique channels to return. YouTube can expose fewer results than requested.

## `minSubscribers` (type: `integer`):

Minimum visible subscriber count. Set to 0 for no minimum. Channels with hidden counts remain in the results.

## `maxSubscribers` (type: `integer`):

Maximum visible subscriber count. Set to 0 for no maximum. Channels with hidden counts remain in the results.

## Actor input object example

```json
{
  "searchQuery": "climate technology podcast",
  "maxResults": 25,
  "minSubscribers": 5000,
  "maxSubscribers": 250000
}
```

# Actor output Schema

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

Structured YouTube channel records found for the requested niche and subscriber filters.

# 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 = {
    "searchQuery": "climate technology podcast",
    "maxResults": 25,
    "minSubscribers": 5000,
    "maxSubscribers": 250000
};

// Run the Actor and wait for it to finish
const run = await client.actor("northglasslabs/youtube-channel-database-search").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 = {
    "searchQuery": "climate technology podcast",
    "maxResults": 25,
    "minSubscribers": 5000,
    "maxSubscribers": 250000,
}

# Run the Actor and wait for it to finish
run = client.actor("northglasslabs/youtube-channel-database-search").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 '{
  "searchQuery": "climate technology podcast",
  "maxResults": 25,
  "minSubscribers": 5000,
  "maxSubscribers": 250000
}' |
apify call northglasslabs/youtube-channel-database-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/v8rPzBYbv16CroV6X/builds/95NPFdBeJNqavdANW/openapi.json