# YouTube Creator Leads & Email Scraper (`axlymxp/youtube-creator-leads`) Actor

Find YouTube creators by keyword or channel URL and get their public business emails, Instagram/TikTok/X links, website, country, subscribers and recent average views. Built for influencer outreach. No login or API key. Pay only for results.

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

## Pricing

from $2.00 / 1,000 dataset items

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/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 Creator Leads & Email Scraper

Build outreach lists of YouTube creators in any niche. Type a few keywords (or paste channel URLs) and get one row per
channel with the **public business email**, Instagram/TikTok/X/Facebook/LinkedIn profiles, website, country,
subscribers, and **engagement numbers you can qualify on**: average and median views of the last 10 videos, days since
the last upload and uploads in the last 30 days.

Made for influencer-marketing agencies, brands running creator campaigns, sponsorship marketplaces, PR teams and
anyone who needs creators they can actually contact. No YouTube login, no API key, no cookies.

### What you get

| Field | Description |
| --- | --- |
| `title`, `handle`, `channelUrl`, `channelId`, `avatarUrl` | Who the creator is |
| `primaryEmail` | Best public email found (own domain or free-mail first, domain checked) |
| `emails[]` | Every public email with `source` (`about`, `video`, `website`, `link_hub`), `sourceDetail` (the video or page it came from), `confidence` and `mxValid` |
| `hasHiddenBusinessEmail` | `true` when YouTube holds a business email behind its "Sign in to see email address" button (not revealed by this actor) |
| `instagramUrl`, `tiktokUrl`, `xUrl`, `facebookUrl`, `linkedinUrl`, `socials{}` | Social profiles from the About page and link-in-bio pages |
| `websites[]`, `links[]` | Creator's own websites and every About-page link |
| `subscriberCount`, `viewCount`, `videoCount`, `joinedDate`, `country`, `description` | Channel stats from the About page |
| `avgViewsRecent`, `medianViewsRecent`, `recentVideosCounted` | Views over the 10 newest uploads |
| `lastUploadDaysAgo`, `uploadsLast30Days` | Is the channel active, and how often it posts |
| `searchQuery`, `foundVia`, `scrapedAt` | Where the row came from |

The **Emails** view of the dataset lists one email per line, ready for a CRM or mail-merge import.

### Where the emails come from

1. The channel's About description ("For business inquiries: …").
2. The descriptions of the channel's most recent videos (many creators only put their sponsor email there).
3. The creator's own website and its contact/about/impressum pages, and link-in-bio pages (Linktree, Stan, solo.to …).

Only emails that are publicly listed are returned. When YouTube hides the business email behind its sign-in button,
the row says so (`hasHiddenBusinessEmail: true`) so you can reveal it by hand for the channels you care about.

### Use cases

- **Influencer marketing:** find 200 micro-creators (10K–100K subscribers) in a niche who posted in the last 30 days and
  have a public email, then sort by median views.
- **Brand sponsorships:** shortlist channels whose average views justify a sponsored segment.
- **Agency lead generation:** creators are businesses; sell them editing, thumbnails, management or software.
- **Market research:** map who publishes about a topic, by country and size.

### Input

| Field | What it does |
| --- | --- |
| `searchQueries` | Keywords; each one can find up to ~600 channels |
| `channelUrls` | Channel URLs, @handles, channel IDs or any video URL to enrich directly |
| `discovery` | Channel search, video search, both (default), or only videos uploaded this month |
| `maxChannelsPerQuery` | Rows to save per keyword |
| `onlyWithEmail` | Save only channels with a public email (skipped channels are not charged) |
| `minSubscribers` / `maxSubscribers` | Size filter |
| `countries` / `keepUnknownCountry` | Country filter (English names as YouTube shows them) |
| `activeWithinDays` | Skip channels that have not uploaded recently |
| `recentVideosToScan` | How many recent video descriptions to read for emails (default 3) |
| `crawlWebsites` | Visit the creator's own site and link-in-bio page (default on) |
| `validateEmails` | Check that each email domain can receive mail (default on) |

Example input:

```json
{
    "searchQueries": ["home espresso", "budget travel"],
    "discovery": "videos_this_month",
    "maxChannelsPerQuery": 100,
    "minSubscribers": 10000,
    "maxSubscribers": 250000,
    "onlyWithEmail": true,
    "recentVideosToScan": 5
}
```

### Example output (one row, values illustrative)

```json
{
    "channelId": "UCxxxxxxxxxxxxxxxxxxxxxx",
    "title": "Example Woodworking",
    "handle": "@ExampleWoodworking",
    "channelUrl": "https://www.youtube.com/@ExampleWoodworking",
    "country": "United States",
    "subscriberCount": 397000,
    "viewCount": 28227701,
    "videoCount": 73,
    "joinedDate": "2014-08-20",
    "primaryEmail": "sponsorships@example-agency.com",
    "emails": [
        {"email": "sponsorships@example-agency.com", "source": "about", "sourceDetail": "channel About page", "confidence": "high", "mxValid": true}
    ],
    "emailCount": 1,
    "hasHiddenBusinessEmail": true,
    "websites": ["https://www.example-woodworking.com"],
    "instagramUrl": "https://www.instagram.com/examplewoodworking",
    "facebookUrl": "https://www.facebook.com/ExampleWoodworking",
    "socials": {"instagram": "https://www.instagram.com/examplewoodworking", "patreon": "https://www.patreon.com/ExampleWoodworking"},
    "recentVideosCounted": 10,
    "avgViewsRecent": 185000,
    "medianViewsRecent": 156500,
    "lastUploadDaysAgo": 14,
    "uploadsLast30Days": 1,
    "searchQuery": "woodworking",
    "foundVia": "channels",
    "scrapedAt": "2026-10-19T01:26:59Z"
}
```

### Scheduling and integrations

Run it on a schedule (for example weekly with `discovery: videos_this_month`) to catch new and newly active creators,
and send the dataset to Google Sheets, HubSpot, Airtable, Make, Zapier or a webhook from the run's Integrations tab.
Re-running the same input after an interruption resumes where it stopped without duplicate rows.

### Use it from AI assistants

The actor works as a tool through the Apify MCP server, so Claude, ChatGPT and other agents can call it with a keyword
and filters and get creators back as JSON.

### FAQ

**Does it reveal the email behind YouTube's "Sign in to see email address" button?**
No. That address needs a signed-in Google account and a CAPTCHA, so the actor only flags it with `hasHiddenBusinessEmail`.

**How many channels have a public email?**
It depends on the niche. In our tests about 60% of tech-review channels and 12% of fitness-coach channels listed one.
Raise `recentVideosToScan` for more emails; use `onlyWithEmail` to pay only for channels with an email.

**How many channels can one keyword return?**
YouTube's search stops after roughly 300 channels per search type, so channel + video search reach about 600 per
keyword. Add related keywords for bigger lists; channels are never repeated across keywords in a run.

**Do I need a proxy?**
No. If YouTube starts rate-limiting, the actor switches to Apify Proxy by itself.

**Is this legal?**
The actor reads public pages only and does not log in. You are responsible for how you contact people: follow
anti-spam law (CAN-SPAM, GDPR/ePrivacy, CASL) and the platforms' terms.

**Why is `country` empty for some channels?**
Many creators do not set a country on their channel (in our tests 10–45% depending on the niche).

# Actor input Schema

## `searchQueries` (type: `array`):

Niches or topics to find creators for, e.g. "tech review", "keto recipes", "dropshipping". Each keyword finds up to ~600 channels.

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

Channels to enrich directly: channel URL, @handle, UC… channel ID or any video URL of the channel.

## `discovery` (type: `string`):

Channel search finds channels named after the keyword; video search finds creators who post videos about it (often a different, more active set). Both is the widest reach.

## `maxChannelsPerQuery` (type: `integer`):

Stop a keyword after this many channels are saved. Each saved channel is one billable result.

## `onlyWithEmail` (type: `boolean`):

Save only channels where a public email was found. Channels without one are skipped and not charged.

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

Skip channels with fewer subscribers.

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

Skip channels with more subscribers (useful for micro-influencer lists).

## `countries` (type: `array`):

Keep only channels whose About page lists one of these countries, in English as YouTube shows them, e.g. "United States", "United Kingdom", "India".

## `keepUnknownCountry` (type: `boolean`):

Many channels (10–45% depending on the niche) do not show a country. Only used together with Countries.

## `activeWithinDays` (type: `integer`):

Skip channels whose newest upload is older than this.

## `recentVideosToScan` (type: `integer`):

Many creators only put their business email in video descriptions. More videos = more emails, slower runs.

## `crawlWebsites` (type: `boolean`):

Visit the links on the channel's About page (own website, Linktree and similar) and their contact pages for emails and social profiles.

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

Adds mxValid to each email: whether its domain can receive mail.

## `maxConcurrency` (type: `integer`):

How many channels are processed at the same time.

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

Not needed: YouTube answers Apify's servers directly. If YouTube starts rate-limiting, the actor switches to Apify Proxy by itself.

## Actor input object example

```json
{
  "searchQueries": [
    "tech review"
  ],
  "discovery": "channels_and_videos",
  "maxChannelsPerQuery": 20,
  "onlyWithEmail": false,
  "keepUnknownCountry": true,
  "recentVideosToScan": 3,
  "crawlWebsites": true,
  "validateEmails": true,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        "tech review"
    ],
    "maxChannelsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/youtube-creator-leads").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 = {
    "searchQueries": ["tech review"],
    "maxChannelsPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/youtube-creator-leads").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 '{
  "searchQueries": [
    "tech review"
  ],
  "maxChannelsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axlymxp/youtube-creator-leads --silent --output-dataset

```

## MCP server setup

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

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/kj3C7l2yIxMFrlgKZ/builds/UMngiZuFkyWEwPiFB/openapi.json