# YouTube Channel Email Scraper (`data_minds/youtube-channel-email-scraper`) Actor

Find contact emails, social links, subscriber and view counts and recent activity for any YouTube channel from links, @handles, IDs, videos or keywords. No login or API key. Bulk input, auto proxy fallback. Export JSON, CSV or Excel for outreach.

- **URL**: https://apify.com/data_minds/youtube-channel-email-scraper.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $35.00 / 1,000 emails

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Email Scraper — emails, socials, stats and activity

**YouTube Channel Email Scraper** reads public YouTube channel pages and returns each channel's contact emails, social and website links, subscriber and view counts, and how active the channel is. It accepts channel links, @handles, channel IDs, video links and search keywords. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed an outreach pipeline. No YouTube login, cookies or API key are needed. Use it to build creator lead lists that stay fresh with every run.

### Why Choose This YouTube Channel Email Scraper?

- Bulk input: paste hundreds of channels, or let keyword search find them.
- Emails come with their source, type (role, business or personal) and a domain check, and one best email is picked for outreach.
- Results appear in the Output tab while the run is still going, split into separate tables for channels, emails, links and recent videos.
- Starts without a proxy and moves to stronger proxies on its own if YouTube rejects requests.

### Key Features

- Scrape YouTube channel emails from the About page and the 15 latest video descriptions.
- Optional deep search: linked websites, link-in-bio pages (Linktree and similar) and the pinned comment of the latest video.
- Social links: Instagram, X, LinkedIn, Facebook, TikTok, Discord, Telegram, Twitch, Patreon, WhatsApp, Threads.
- Channel stats: subscribers, total views, video count, country, join date, badges and tabs (Shorts, live, podcasts, store, posts).
- Activity: last upload, uploads per month, average and median views, average likes, engagement rate, sponsorship signals.
- Subscriber-range filter that skips channels before the heavy work.

### Input

```json
{
  "urls": ["https://www.youtube.com/@mkbhd", "@veritasium", "UCBJycsmduvYEL83R_U4JriQ", "https://youtu.be/dQw4w9WgXcQ"],
  "searchQueries": ["tech review"],
  "maxChannels": 25,
  "subscribers": "10k-500k",
  "emailSearch": "standard",
  "validateEmails": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

| Field | What it does |
|---|---|
| `urls` (required) | Channel links, @handles, channel IDs (UC…) or video links, one per line. |
| `searchQueries` | Keywords that discover additional channels. |
| `maxChannels` | Channels to collect for each search keyword; every keyword gets its own count (0 = as many as search returns). |
| `subscribers` | Size filter such as `10k-500k`, `1k+`, `-100k`. Empty = any size. |
| `emailSearch` | `standard` (About page + latest video descriptions) or `deep` (+ linked websites, link-in-bio pages, pinned comment). |
| `validateEmails` | Checks that each email domain accepts mail and flags throwaway domains and typos. |
| `proxyConfiguration` | Optional. The default needs no setup. |

### Output

One row per channel in the default table. Example (shortened):

```json
{
  "channelName": "Marques Brownlee",
  "channelHandle": "@mkbhd",
  "channelId": "UCBJycsmduvYEL83R_U4JriQ",
  "subscriberCount": 21400000,
  "country": "United States",
  "bestEmail": "business@mkbhd.com",
  "bestEmailType": "role",
  "emails": [{ "email": "business@mkbhd.com", "source": "channel_about", "type": "role", "validation": "valid" }],
  "hasHiddenEmail": true,
  "instagramUrl": "http://instagram.com/MKBHD",
  "lastUploadDate": "2026-10-21",
  "uploadsPerMonth": 11.1,
  "avgViewsRecent": 10526379,
  "engagementRate": 1.4,
  "status": "ok (business email exists but is behind YouTube sign-in)"
}
```

| Group | Fields |
|---|---|
| Channel | `channelName`, `channelHandle`, `channelId`, `channelUrl`, `description`, `keywords`, `subscriberCount`, `viewCount`, `videoCount`, `country`, `joinedDate`, `thumbnailUrl`, `bannerUrl`, `isVerified`, `isArtistChannel`, `isFamilySafe`, `hasStore`, `hasShorts`, `hasLiveStreams`, `hasPodcasts`, `hasCommunityPosts` |
| Email | `bestEmail`, `bestEmailType`, `youtubeEmail`, `youtubeEmailValidation`, `emails`, `emailCount`, `hasEmail`, `hasHiddenEmail`, `phoneNumbers` |
| Links | `websiteUrl`, one `…Url` field per social platform, `hasLinks`, `primaryAggregatorUrl`, `socialLinks`, `allLinks` |
| Activity | `lastUploadDate`, `daysSinceLastUpload`, `isActive`, `uploadsLast30Days`, `uploadsPerMonth`, `avgViewsRecent`, `medianViewsRecent`, `avgLikesRecent`, `engagementRate`, `recentVideos`, `sponsorshipSignals`, `hasSponsoredContent` |
| Meta | `status`, `scrapedAt`, `inputUrl`, `error` |

Separate tables in the Output tab: Emails (one row per address), Links (one row per link) and Recent videos (one row per upload). Inputs that cannot be read stay in the main table with a reason in `error`.

Email `validation` values: `valid`, `no_mx`, `invalid`, `disposable`, `typo`, `unknown`, `not_checked`. A `valid` result means the domain accepts mail, not that the mailbox exists.

### 🚀 How to Use (Apify Console)

1. Log in at https://console.apify.com → Actors and open YouTube Channel Email Scraper.
2. Paste your channels into the first field and add keywords if you want more.
3. Pick `standard` or `deep` email search.
4. Click Start and watch the log: every saved channel appears as a line with its subscribers and emails.
5. Open the Output tab when the run completes and export JSON, CSV or Excel.

### 🤖 Use via API / MCP

```bash
curl -X POST "https://api.apify.com/v2/actors/<ACTOR_ID>/runs" \
     -H "Authorization: Bearer $APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"urls":["@mkbhd"],"emailSearch":"standard"}'
```

AI agents can find this Actor through the Apify MCP server (`claude mcp add --transport http apify "https://mcp.apify.com"`) with its search, details and call tools.

### Best Use Cases

- Influencer outreach and sponsorship prospecting.
- Agency lead lists of creators in a niche, filtered by subscriber range.
- Finding active channels (last upload, upload cadence, engagement rate) before reaching out.
- Enriching a creator database with socials and websites.

### Frequently Asked Questions

Does it need a YouTube login? No. It reads public pages only.

Why is `hasHiddenEmail` true but no email returned? YouTube shows a channel's business email only after Google sign-in and a CAPTCHA. The Actor tells you the email exists but does not try to log in.

Are subscriber counts exact? They are YouTube's rounded public figures (for example 21.4M). `viewCount` is exact.

What does deep search add? Emails found on linked websites (home, contact and about pages), link-in-bio pages and the pinned comment of the latest video. Websites behind bot protection are skipped.

What if the layout changes? Values that change over time are read fresh on every run, and the Actor keeps working when a field cannot be read: you get the other fields and an explanatory `status`.

Can I search by keyword only? Yes: add keywords and set `maxChannels`. The channel field still needs at least one entry, so add a channel you care about.

### Support and Feedback

Open an issue from the Actor page in Apify Console. Data is collected only from publicly available pages; you are responsible for using it in line with GDPR, CCPA, anti-spam laws and YouTube's terms.

# Actor input Schema

## `urls` (type: `array`):

Channels to scrape, one per line. Accepts channel links (https://www.youtube.com/@mkbhd), @handles, channel IDs (UC…) and video links (the channel of the video is used). Bulk lists are welcome.

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

Optional. Keywords to discover additional channels, for example tech review or cooking vlog. Channels found are scraped as well.

## `maxChannels` (type: `integer`):

Number of channels to collect for EACH search keyword (every keyword gets its own count). 0 means as many as the search can return. Channels you list above are always scraped. Free plan: up to 10 channels per keyword and the first 10 listed channels.

## `subscribers` (type: `string`):

Only keep channels in this size range, for example 10k-500k, 1k+ or -100k. Leave empty for any size.

## `emailSearch` (type: `string`):

Standard checks the channel About page and the 15 latest video descriptions. Deep also checks linked websites, link-in-bio pages and the pinned comment of the latest video.

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

Checks that every email domain accepts mail, flags throwaway domains and typos, and picks the best address to contact. A passed check does not prove the mailbox exists.

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

Runs start without a proxy. If the requests are rejected, the Actor switches to stronger proxies on its own and keeps using them for the rest of the run. Choose Apify Proxy here only if you want to start with a proxy.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/@mkbhd",
    "@veritasium"
  ],
  "searchQueries": [
    "football"
  ],
  "maxChannels": 10,
  "subscribers": "",
  "emailSearch": "standard",
  "validateEmails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per channel with emails, links, stats and activity.

## `emails` (type: `string`):

One row per email address.

## `links` (type: `string`):

One row per channel link.

## `videos` (type: `string`):

One row per recent upload.

## `summary` (type: `string`):

Counts for the finished 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 = {
    "urls": [
        "https://www.youtube.com/@mkbhd",
        "@veritasium"
    ],
    "searchQueries": [
        "football"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/youtube-channel-email-scraper").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 = {
    "urls": [
        "https://www.youtube.com/@mkbhd",
        "@veritasium",
    ],
    "searchQueries": ["football"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/youtube-channel-email-scraper").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 '{
  "urls": [
    "https://www.youtube.com/@mkbhd",
    "@veritasium"
  ],
  "searchQueries": [
    "football"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_minds/youtube-channel-email-scraper --silent --output-dataset

```

## MCP server setup

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

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/Qo10XRp3bvG2EQNvZ/builds/bYZmnATfHky0bgvsc/openapi.json