# YouTube Channel Finder — Find Channels by Keyword (`northbell/youtube-channel-finder`) Actor

Find YouTube channels by keyword, in YouTube's own order: handle, subscribers, video count, description and verified badge, with new channels flagged since your last run. Turn on enrich for exact total views, country, join date and links. Filter by minimum subscribers. No login.

- **URL**: https://apify.com/northbell/youtube-channel-finder.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Social media, Lead generation, Videos
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 channels

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/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 Channel Finder

Give it keywords and get the **YouTube channels** that match, in YouTube's own order: **handle, subscribers, video count (when YouTube shows it), verified badge and the channel's description**, one clean row per channel. Filter by **minimum subscribers** and pick the country. **$1 per 1,000 channels**, no login, no API key.

Run it again — or put it on a schedule — and every row also tells you **what changed since the last run of that keyword**: its previous rank, how many places it moved, and `isNewForKeyword`, which flags **channels that have just appeared** in the results (a channel that was listed in any earlier run is never flagged). That is how you spot new competitors, creators and brand-name channels as they start, which a one-off list cannot show.

Turn on **Enrich** and each channel's About panel is read too: **exact total views, exact video count, country, join date and external links** (Instagram, website…) — $2.50 per 1,000 channels instead of $1.

### What you get

| Field | What it is |
|---|---|
| `keyword`, `searchRegion`, `rank` | the keyword, the country you searched in, and the channel's position in YouTube's channel results (1 = first) |
| `previousRank`, `rankChange`, `isNewForKeyword` | compared with your previous run of the same keyword and country (`null` on the first run; positive `rankChange` = moved up) |
| `channelId`, `handle`, `name`, `url`, `verified` | the channel (`verified` is `true` for the check mark and for official artist channels). Many channels are named after an email address: that address is replaced by `[email removed]` in `name`, or by the @handle when nothing else is left |
| `subscribers`, `subscribersText` | subscribers as YouTube shows them — **YouTube rounds this** (28.3K → 28,300); `null` when the channel hides its count |
| `videoCount`, `videoCountExact` | number of videos, in search only for channels without an @handle; with Enrich always, from the About panel. `videoCountExact` is `false` if the text was rounded ("1.8K videos") |
| `descriptionSnippet` | the start of the channel description as YouTube shows it in search, with **email addresses and phone numbers removed** |
| `enriched`, `totalViews`, `country`, `joinedAt`, `links` | with Enrich: exact lifetime views, where the channel says it is, when it started (`2008-03-21`) and its external links (`title`, `url`; `tel:` links and links that contain an email address are left out) |
| `enrichNote` | only on a row where Enrich could not read the About panel (`enriched` is then `false`) |
| `observedAt`, `type` | when the row was read; `channel` or `error` |

### Use it for

- **Influencer and creator discovery** — every channel in a niche with its size, links and start date, filtered to the ones above your minimum subscribers
- **Competitor and newcomer watch** — schedule a keyword daily and read off `isNewForKeyword` to see who just showed up
- **Market mapping** — how many channels cover a topic, how large they are, which are verified
- **Brand and product monitoring** — find channels named after your brand, product or competitor

### Input

```json
{ "keywords": ["home espresso", "latte art"], "maxChannelsPerKeyword": 100, "minSubscribers": 1000, "country": "US", "enrich": true }
```

Ranks are remembered per keyword and country in a named key-value store in your Apify account, so the second run of the same Actor already shows changes. Schedule it (Apify → Schedules) for a daily history.

Measured on October 7, 2026: 60 channels for one keyword in 4 seconds; 40 channels with Enrich in 38 seconds.

### Pricing

**$1 per 1,000 channels**, or **$2.50 per 1,000 with Enrich**, plus $0.01 per run. Error rows and channels left out by *Minimum subscribers* are free. A channel whose About panel could not be read is charged the plain $1 price (and says so in `enriched` and `enrichNote`). The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- **Country.** YouTube ranks mostly by where the request comes from, and Apify's servers are in the US, so results are close to what a signed-out viewer in the US sees, in English. The `country` code is passed to YouTube as a hint: measured on 8 October 2026, `news` gave the same four channels for US and JP (two swapped places). Treat other countries as approximate. YouTube personalises results for signed-in users, so your own screen can differ.
- **How many channels exist per keyword:** YouTube's channel list is cut off at roughly 250 to 300 channels even for a broad word (measured: 265 for "coffee"), and fewer for narrow ones. Asking for 300 returns what exists.
- **The list is not stable.** YouTube hands out a different slice of its channel list on every call, so two runs seconds apart can disagree about which channels are in your top 60 (measured on October 7: between 3 and 31 of 60 channels were missing from the previous run, depending on the keyword). Read `rankChange` as a direction over days, not as an exact move.
- **`isNewForKeyword` gets reliable from the third run.** It is `true` only for a channel that has never been listed for that keyword and country in any earlier run (the last 1,500 channels are remembered), so a channel that merely dropped out for a run and came back is not flagged. Measured on one keyword read four times in a row: 31, 6 and 1 channels flagged on runs 2, 3 and 4 — against 31, 13 and 21 if only the previous run counted. Treat run 1 and 2 as the baseline, then schedule it.
- `rank` is the position among *all* channels YouTube lists, so it has gaps when *Minimum subscribers* leaves channels out. *Max channels per keyword* counts only the channels that pass the filter. Channels that hide their subscriber count are left out when a minimum is set (0 or empty means no minimum).
- `isNewForKeyword` is `null` for every row of the first run, and for channels below the depth your previous run read (they cannot be called new). `previousRank` and `rankChange` are `null` for a channel that was not in the previous run.
- `videoCount` and `videoCountExact` are empty for channels that have an @handle unless Enrich is on: YouTube's search shows their subscribers instead of a video count. Some auto-generated "- Topic" channels show a different number in search than on their own page; Enrich gives the page's number.
- `handle` is `null` for channels without an @handle (older channels and auto-generated "- Topic" channels); `url` then uses the channel ID. `subscribers` is `null` when a channel hides its count. `descriptionSnippet` is `null` when the channel has no description.
- With Enrich, `country` and `links` are filled only when the channel has set them (in a test of 80 channels, 40 had a country and 32 had links). `totalViews` and the exact `videoCount` stay `null` when the About panel shows no number — channels without videos, and brand-new ones (6 of 80 in the same test). Enrich takes about a second per channel; if YouTube keeps refusing detail requests the run stops asking and returns the rest as plain rows.
- Public data only: what anyone sees without signing in. No emails or phone numbers are returned — they are removed from descriptions, channel names and link titles.

To **track the channels you find** (exact views per day, new videos, subscriber change), give their handles to [YouTube Channel Stats & Growth Tracker](https://apify.com/northbell/youtube-channel-growth-tracker). To see **where videos rank** for the same keywords, see [YouTube Search Rank Tracker](https://apify.com/northbell/youtube-search-rank-tracker).

### For AI agents

`{"keywords": ["home espresso"], "maxChannelsPerKeyword": 5}` returns 5 channels with rank, handle, subscribers and a description snippet. Rows have `type`: `channel` or `error`.

# Actor input Schema

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

What you would type in the YouTube search box. Each keyword returns the matching channels in YouTube's order, one row per channel.

## `maxChannelsPerKeyword` (type: `integer`):

How many channels to return for each keyword (about 20 per results page). YouTube's list for one keyword ends at roughly 250 to 300 channels, so very high values may return fewer.

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

Return only channels with at least this many subscribers. Leave empty (or 0) for no minimum. With a minimum, channels that hide their subscriber count are left out. Left-out channels are free.

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

Two-letter country code, e.g. US, GB, IN, JP, passed to YouTube as a hint. YouTube ranks mostly by where the request comes from (Apify's servers are in the US), so other countries are approximate.

## `enrich` (type: `boolean`):

Open each channel's About panel to add exact total views, exact video count, country, join date and external links. Costs $2.50 per 1,000 channels instead of $1, and the run is slower.

## Actor input object example

```json
{
  "keywords": [
    "home espresso"
  ],
  "maxChannelsPerKeyword": 50,
  "country": "US",
  "enrich": false
}
```

# Actor output Schema

## `channels` (type: `string`):

Channels for your keywords with rank, subscribers, video count, description and whether they are new since the last run.

# 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": [
        "home espresso"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/youtube-channel-finder").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": ["home espresso"] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/youtube-channel-finder").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": [
    "home espresso"
  ]
}' |
apify call northbell/youtube-channel-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbell/youtube-channel-finder"
        }
    }
}
```

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/ebbyfxZNdodh8mfeK/builds/v1TvRekrRTUjj7i39/openapi.json