# YouTube Creator Finder - Search by Niche, Get Contacts (`salomon.labs/youtube-creator-finder`) Actor

Find YouTube creators by niche, filter them by subscriber count and country, and get their profile, links and public contact email - each one validated with a plain-English send recommendation.

- **URL**: https://apify.com/salomon.labs/youtube-creator-finder.md
- **Developed by:** [Alan Salomon](https://apify.com/salomon.labs) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 creator profiles

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 Creator Finder

**Tell it a niche. Get back the creators, filtered the way you actually build an
outreach list — with their contact email where they publish one.**

Most YouTube contact tools need you to already have a list of channels. This one
finds them. You give it *"sourdough baking"* and a subscriber range, and it
returns creators in that band with their size, country, links, and a validated
contact address where one is publicly available.

***

### What you get, per creator

| | |
|---|---|
| **Who** | Channel name, handle, URL, channel ID, country |
| **How big** | Subscribers, videos, total views, **views per video** |
| **How established** | Year they joined |
| **Where else** | Their website, and every social link |
| **Contact** | Public business email, **the exact URL it was found at**, plus any extras |
| **Whether to use it** | A plain-English send recommendation for that address |
| **Why they're in your list** | The keyword that found them |

***

### Be clear about the email before you run this

**YouTube hides most creators' business emails behind a "View email address"
button that requires a Google login and a CAPTCHA. This Actor does not bypass
that**, and it never will — that route needs pools of logged-in accounts and a
CAPTCHA-solving service, and it gets people banned.

So here is the honest number, measured on real mid-sized channels:

- **Roughly 1 in 7 mid-sized creators** (5k–500k subscribers) publish an address
  we can read — in their description, or on their own website's contact page.
- **Around half of them have an address behind YouTube's login.** We can't read
  it, but we *tell you it exists*, so you know which creators are worth chasing
  another way.
- **Every creator returns a full profile**, contact or not.

Large channels publish addresses far more often than small ones. If you need a
guaranteed address for a specific channel, use a tool that logs in — and expect
to pay roughly thirty times more per email.

**This Actor is built for the other job:** building a shortlist of the right
creators, fast and cheap, and taking the contacts that come free with it.

***

### Every email arrives already checked

Other tools hand you a string and wish you luck. Each address here is run through
a verification engine — syntax, live domain, working mail route, disposable
detection, role-inbox detection, free-provider detection — and comes back with a
recommendation:

| Recommendation | Meaning |
|---|---|
| `send` | A business inbox the creator published for enquiries, on a working mail host. This is the one you want. |
| `send_low_volume` | Real and reachable, but a customer-service inbox or a thinner signal. Usable; start small. |
| `manual_review` | Worth a human glance before sending. |
| `suppress` | Don't send. Dead domain, disposable, or an unattended `noreply@`. |

**Branch on the recommendation, not on the score.** Without SMTP probing the
confidence ceiling caps `safe_to_send_score` around 45 even for good addresses —
that is the engine refusing to claim certainty it doesn't have, not a low grade.

***

### Input

```json
{
  "searchKeywords": ["sourdough baking", "home workout fitness"],
  "minSubscribers": 5000,
  "maxSubscribers": 500000,
  "maxCreators": 25
}
```

Already have channels? Pass them directly and skip the search:

```json
{ "channelUrls": ["@NetworkChuck", "https://www.youtube.com/@mkbhd", "UCBJycsmduvYEL83R_U4JriQ"] }
```

Handles, full URLs and `UC...` IDs all work, and you can mix them.

**`maxCreators` is your cost ceiling.** Channels are filtered by size *before*
that limit applies, so your budget is spent on creators that match rather than on
the giants the search happened to rank first.

***

### Why the subscriber filter matters

It's the filter every outreach playbook is built on and most tools don't offer.
Mega-channels route cold approaches through an agency; very small channels don't
move product. The creators worth pitching sit in a band — and this Actor lets you
name it.

It's also why the run is cheap: filtering happens on search results, and only
creators who survive the filter get fully fetched.

***

### Output

One row per creator, every column a plain value, identical shape whether the
lookup succeeded or failed — so a spreadsheet formula written on row 2 still works
on row 200. Use the **Creators** view for the full picture or **Contacts only**
for the shortlist with an address.

A final `SUMMARY` row reports what happened: how many channels were discovered,
how many made the shortlist, how many produced a contact, and how many have one
behind YouTube's login.

***

### What it does not do

- **No login-gated emails.** Stated above, repeated here.
- **No sponsor addresses.** Creator link lists are full of sponsors and affiliate
  codes. Only sites that appear to belong to the creator are followed, so you
  don't get a mattress company's address labelled as a fitness creator's. That
  costs a little reach and is worth it.
- **No guessed addresses.** Nothing is constructed from a name and a domain.
  Everything returned was found somewhere, and the row tells you where.
- **No mailbox confirmation.** Nothing here proves a mailbox exists — that needs
  SMTP. We check everything short of it and say so plainly.

# Actor input Schema

## `searchKeywords` (type: `array`):

What kind of creators you want, in the words you would type into YouTube. One niche per line, e.g. 'sourdough baking' or 'home workout fitness'. Leave empty if you are supplying channel URLs below.

## `channelUrls` (type: `array`):

Channel handles (@name), full channel URLs, or channel IDs (UC...). Use this when you already have a list. These are always processed, and are not affected by the subscriber filters below.

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

Skip creators below this size. Outreach shortlists are built in bands: very small channels rarely move product.

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

Skip creators above this size. Mega-channels usually ignore cold approaches and route everything through an agency.

## `maxCreators` (type: `integer`):

A hard ceiling on how many creator profiles this run produces, and therefore on what it costs. Channels are filtered by size BEFORE this limit applies, so you spend the budget on creators that match.

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

How many channels to pull from YouTube per keyword before filtering. Searching is cheap; raise it if a narrow subscriber band is leaving you with too few matches.

## `scanCreatorWebsites` (type: `boolean`):

When a creator publishes no address on YouTube, look for one on their own site's contact page. Only sites that appear to belong to the creator are followed - sponsor and affiliate links are ignored on purpose. Turning this off makes runs faster and finds fewer contacts.

## `validateEmails` (type: `boolean`):

Check each address for syntax, a live domain, a working mail route, disposable and role-inbox status, and return a plain-English send recommendation. Leave on unless you only want raw strings.

## Actor input object example

```json
{
  "searchKeywords": [
    "home workout fitness",
    "sourdough baking"
  ],
  "channelUrls": [
    "@NetworkChuck",
    "https://www.youtube.com/@mkbhd"
  ],
  "minSubscribers": 5000,
  "maxSubscribers": 500000,
  "maxCreators": 25,
  "maxChannelsPerKeyword": 40,
  "scanCreatorWebsites": true,
  "validateEmails": true
}
```

# Actor output Schema

## `creators` (type: `string`):

One row per creator: profile, size, links, contact email and its verdict.

## `creatorsCsv` (type: `string`):

The same rows as a spreadsheet-ready CSV.

# 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 = {
    "searchKeywords": [
        "sourdough baking"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("salomon.labs/youtube-creator-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 = { "searchKeywords": ["sourdough baking"] }

# Run the Actor and wait for it to finish
run = client.actor("salomon.labs/youtube-creator-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 '{
  "searchKeywords": [
    "sourdough baking"
  ]
}' |
apify call salomon.labs/youtube-creator-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,salomon.labs/youtube-creator-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/KpdrwY4e3HWJGSeVg/builds/qZyp0PAsoqA7XUCee/openapi.json