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

Find public contact emails displayed by YouTube channels and export source-attributed emails, links, social profiles, and channel metadata.

- **URL**: https://apify.com/fetch\_cat/youtube-channel-email-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 channel results

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 Email Scraper

Find public business and contact emails explicitly displayed by YouTube channels. Export source-attributed emails together with channel metadata, outbound websites, social profiles, and clear no-contact or failure statuses.

Use this YouTube email scraper and YouTube contact scraper for creator outreach, partnership research, sponsorship prospecting, and contact-list enrichment from channels you already know. It works as a YouTube creator email finder or YouTube influencer email finder only for addresses displayed on public pages. It does not log in, reveal CAPTCHA-protected addresses, or infer email addresses.

### Example input

```json
{
  "channelUrls": [
    "https://www.youtube.com/@rebeccazamolo",
    "@imjennim",
    "UCTgwcoeGGKmZ3zzCXN2qo_A"
  ],
  "maxChannels": 3,
  "onlyWithEmail": false,
  "includePublicLinkedWebsites": false,
  "includePhones": false
}
```

### Example output

```json
{
  "input": "@imjennim",
  "channelUrl": "https://www.youtube.com/@imjennim/about",
  "channelId": "UCgWfS_47YPVbKx5EK4FLm4A",
  "handle": "@imjennim",
  "title": "Jenn Im",
  "description": "Business Inquiries: jenn@rare.global ...",
  "subscriberCountText": "3.23M subscribers",
  "subscriberCount": 3230000,
  "videoCountText": "794 videos",
  "videoCount": 794,
  "viewCountText": "1,555,888 views",
  "viewCount": 1555888,
  "country": "United States",
  "joinedDateText": "Joined Feb 28, 2010",
  "verified": false,
  "externalLinks": [],
  "socialLinks": [],
  "websiteLinks": [],
  "emails": [{
    "value": "jenn@rare.global",
    "sourceUrl": "https://www.youtube.com/@imjennim/about",
    "sourceType": "channel_about",
    "confidence": "high"
  }],
  "phones": [],
  "contactStatus": "FOUND_PUBLIC_CONTACT",
  "hiddenEmailUnsupported": false,
  "pagesChecked": 0,
  "pagesSkipped": 0,
  "errorCode": null,
  "errorMessage": null,
  "scrapedAt": "2026-08-13T12:11:26.764Z"
}
```

### Input settings

| Field | Type | Description |
|---|---|---|
| `channelUrls` | string\[] | YouTube channel URLs, About URLs, `@handles`, bare handles, or `UC...` channel IDs. |
| `maxChannels` | integer | Maximum unique channels to process (1–500). |
| `onlyWithEmail` | boolean | Save only rows containing at least one public email. |
| `includePublicLinkedWebsites` | boolean | Also inspect a bounded number of publicly linked website pages for displayed contacts. |
| `maxExternalPagesPerChannel` | integer | Maximum linked website pages checked per channel (0–10). |
| `contactPageKeywords` | string\[] | Optional paths such as `contact`, `about`, or `press` considered during website inspection. |
| `includePhones` | boolean | Also collect explicitly displayed public phone numbers. |
| `proxyConfiguration` | object | Optional Apify Proxy configuration. Direct requests are used by default. |

Duplicate inputs are normalized and processed once. Valid rows are saved progressively, so one unavailable channel does not discard successful siblings.

### Output fields

| Field | Description |
|---|---|
| `input` | Original submitted value. |
| `channelUrl` | Normalized public About URL. |
| `channelId`, `handle` | Public channel identifiers when available. |
| `title`, `description` | Public channel title and description. |
| `subscriberCountText`, `subscriberCount` | Display value and normalized count. |
| `videoCountText`, `videoCount` | Display value and normalized count. |
| `viewCountText`, `viewCount` | Display value and normalized count. |
| `country`, `joinedDateText`, `verified` | Public About metadata when supplied by YouTube. |
| `externalLinks` | Public outbound links found on the channel surface. |
| `socialLinks` | Recognized public social links with platform labels. |
| `websiteLinks` | Non-social public outbound links. |
| `emails` | Deduplicated contacts with `value`, `sourceUrl`, `sourceType`, and `confidence`. |
| `phones` | Optional public phones with the same source evidence shape. |
| `contactStatus` | `FOUND_PUBLIC_CONTACT`, `NO_PUBLIC_CONTACT`, `CHANNEL_ERROR`, or `SKIPPED_DEADLINE`. |
| `hiddenEmailUnsupported` | Indicates that the page referenced a protected email flow that this Actor will not access. |
| `pagesChecked`, `pagesSkipped` | External-page processing counters. |
| `errorCode`, `errorMessage` | Per-channel diagnostics; successful sibling rows remain available. |
| `scrapedAt` | ISO timestamp for collection. |

A `RUN-SUMMARY` record in the default key-value store reports submitted channels, saved rows, and deadline cutoff status.

### Who is it for?

- Creator partnership and sponsorship teams building source-auditable outreach lists.
- Agencies researching public contact routes for known channels.
- Sales and market-research teams enriching channel lists with public metadata.
- Developers and AI-agent builders who need structured JSON through API or MCP.

### Input recipes

#### Creator outreach list

Set `onlyWithEmail` to `true` and submit up to 100 known channel handles. Every retained email includes its public source URL.

#### Channel metadata audit

Set `onlyWithEmail` to `false` to retain channels without public contacts and compare metadata and outbound profiles.

#### Public website contact enrichment

Enable `includePublicLinkedWebsites`, keep `maxExternalPagesPerChannel` low, and optionally enable `includePhones`. Website availability and robots/access policies may vary.

### Pricing

Pay per event: one small start event plus one channel-result event per saved row, with plan-based volume discounts. Filtering with `onlyWithEmail` does not charge for omitted rows. See the [live Pricing tab](https://apify.com/fetch_cat/youtube-channel-email-scraper/pricing) for current rates.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/anna%2Fyoutube-channel-email-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channelUrls":["@imjennim"],"maxChannels":1}'
```

**JavaScript:**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/youtube-channel-email-scraper').call({ channelUrls: ['@imjennim'], maxChannels: 1 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/youtube-channel-email-scraper').call(run_input={'channelUrls': ['@imjennim'], 'maxChannels': 1})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP and AI agents

Connect the Apify MCP server at:

`https://mcp.apify.com/?tools=fetch_cat/youtube-channel-email-scraper`

Add it to Claude Code:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=fetch_cat/youtube-channel-email-scraper
```

Or use this MCP configuration:

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

Example prompts: “Find publicly displayed emails for these five YouTube handles and return source URLs” or “Compare metadata for these channels and retain rows without email.” Keep tokens and contact data out of prompts or logs that do not need them.

### Tips and limits

- Start with a few known channels, then expand the batch.
- Channel pages change over time; absent metadata is returned as `null`, not guessed.
- Some business emails are protected behind login or CAPTCHA. Those are intentionally not revealed.
- External website checks are opt-in, bounded, and can be slower or unavailable.
- Use public contact details responsibly and comply with applicable privacy, anti-spam, platform, and marketing laws.
- The Actor discovers contacts from supplied channels; it does not search YouTube by keyword.

### FAQ

#### Does it reveal YouTube's protected “View email address” value?

No. It exports only contact details already displayed on anonymous public surfaces. It does not log in, solve CAPTCHA, bypass controls, or infer addresses.

#### Why does a successful row have no email?

Many channels do not publish one. Keep `onlyWithEmail` off to receive `NO_PUBLIC_CONTACT` rows and useful channel metadata.

#### Can I use it through the API or MCP?

Yes. Use the Actor API from any Apify client or add the actor-specific MCP URL above to an MCP-compatible agent.

#### Does it validate mailbox deliverability?

No. It preserves publicly displayed values and their source evidence; mailbox verification is a separate workflow.

#### What happens if one channel fails?

The row contains `CHANNEL_ERROR` and diagnostics while other channels continue. Results are stored progressively.

### Related Actors

- [YouTube Scraper](https://apify.com/fetch_cat/youtube-scraper)
- [YouTube Comments Scraper](https://apify.com/fetch_cat/youtube-comments-scraper)
- [Instagram Profile Scraper](https://apify.com/fetch_cat/instagram-profile-scraper)
- [TikTok Profile Scraper](https://apify.com/fetch_cat/tiktok-profile-scraper)
- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder)

### Support

For reproducible issues, open the Actor's **Issues** tab and include a redacted input, run ID, expected behavior, and actual behavior. Never post private credentials or non-public contact data.

# Actor input Schema

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

Public YouTube channel URLs such as https://www.youtube.com/@Apify, handles like @Apify, or channel IDs. The Actor uses only public pages and does not reveal hidden YouTube business emails.

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

Maximum number of channels to process from the input list.

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

When enabled, channels without an explicitly displayed public email remain counted in the run summary but are not saved to the dataset.

## `includePublicLinkedWebsites` (type: `boolean`):

When enabled, the Actor visits a bounded number of public pages from channel website links, such as home, contact, about, and team pages.

## `maxExternalPagesPerChannel` (type: `integer`):

Hard limit for public external pages checked per channel. Lower values reduce cost and run time.

## `contactPageKeywords` (type: `array`):

Same-domain path keywords prioritized when looking for contact pages on linked websites.

## `includePhones` (type: `boolean`):

Extract conservative public phone-like strings from channel text and linked public pages.

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

Optional Apify Proxy configuration. Datacenter proxy is usually enough for public pages; residential proxies may increase cost.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Apify",
    "https://www.youtube.com/@OpenAI"
  ],
  "maxChannels": 10,
  "onlyWithEmail": false,
  "includePublicLinkedWebsites": false,
  "maxExternalPagesPerChannel": 2,
  "contactPageKeywords": [
    "contact",
    "about",
    "team",
    "press",
    "media",
    "advertise",
    "partnership"
  ],
  "includePhones": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `runSummary` (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 = {
    "channelUrls": [
        "https://www.youtube.com/@Apify",
        "https://www.youtube.com/@OpenAI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = { "channelUrls": [
        "https://www.youtube.com/@Apify",
        "https://www.youtube.com/@OpenAI",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "channelUrls": [
    "https://www.youtube.com/@Apify",
    "https://www.youtube.com/@OpenAI"
  ]
}' |
apify call fetch_cat/youtube-channel-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/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/8FuMp0KwZ7kJjKOXj/builds/7RM2NW1s8Vrj7O2zy/openapi.json