# YouTube Email Scraper (`crawlerbros/youtube-email-scraper`) Actor

Extract emails from YouTube channels without CAPTCHA bypass. Scans channel About descriptions and follows Instagram, TikTok and Linktree profiles linked from the channel. HTTP-only, no cookies, no API keys.

- **URL**: https://apify.com/crawlerbros/youtube-email-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Lead generation, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 9 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Email Scraper

Extract verified contact emails from any YouTube channel — including the emails hidden in the creator's Instagram, TikTok, or Linktree bios.

### What this actor does

Give the scraper a list of YouTube channel URLs and it returns every public email address the creator advertises. The scraper opens each channel's public About page, pulls channel metadata (name, handle, channel ID, description, subscriber count), and harvests every email literal it finds — including obfuscated variants like `contact [at] example [dot] com`, which are automatically normalised to proper addresses.

Because creators often hide their business email on Instagram or TikTok rather than on YouTube itself, the scraper also follows every Instagram, TikTok, and Linktree link it finds on the channel page and scans those bios for additional addresses. Every email is tagged with its source so you can tell a YouTube-advertised address apart from one picked up on Instagram.

The result is a clean dataset of one record per channel, with all emails deduplicated, fully qualified, and traceable back to the exact page they were found on.

### Key features

- Accepts every YouTube URL format: `@handle`, `/channel/UC...`, `/c/name`, `/user/name`, or a bare `@handle` string
- Harvests emails from the About description, advertised hyperlinks, and `mailto:` anchors
- Follows Instagram, TikTok, and Linktree links and extracts emails from their bios
- Deobfuscates common anti-scraper patterns: `[at]`, `(at)`, ` AT `, `[dot]`, `(dot)`, ` DOT `
- Per-email source attribution — see exactly where each address came from
- Case-insensitive deduplication with stable ordering
- Transparent residential-proxy fallback — direct requests first, proxy only when blocked
- No cookies, no login, no API keys required
- Zero-null output — empty fields are omitted rather than filled with placeholders

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `channelUrls` | array of strings | — | **Required.** YouTube channel URLs in any supported shape. |
| `followExternalProfiles` | boolean | `true` | Follow Instagram / TikTok / Linktree links discovered on the channel. |
| `maxExternalPerChannel` | integer | `3` | Cap on external profiles fetched per channel (0-20). |
| `autoProxyFallback` | boolean | `true` | Automatically retry through Apify residential proxy when a page looks blocked. |

**Example input**

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Apify",
    "https://www.youtube.com/@MrBeast",
    "@MKBHD"
  ],
  "followExternalProfiles": true,
  "maxExternalPerChannel": 3,
  "autoProxyFallback": true
}
````

### Output

One record per channel. Fields with no value are omitted.

```json
{
  "channelUrl": "https://www.youtube.com/@Apify/about",
  "channelId": "UCx...",
  "channelHandle": "@Apify",
  "channelName": "Apify",
  "channelDescription": "We help businesses extract data from the web...",
  "subscriberCount": 12500,
  "emails": ["hello@apify.com", "press@apify.com"],
  "sources": [
    {"email": "hello@apify.com", "sourceUrl": "https://www.youtube.com/@Apify/about", "sourceType": "channel_description"},
    {"email": "press@apify.com", "sourceUrl": "https://www.instagram.com/apify/", "sourceType": "instagram_bio"}
  ],
  "externalLinks": [
    "https://apify.com",
    "https://www.instagram.com/apify/",
    "https://twitter.com/apify"
  ],
  "scrapedAt": "2026-04-24T12:00:00+00:00"
}
```

**Field descriptions**

- **`channelUrl`** — canonical URL of the scraped About page
- **`channelId`** — YouTube's stable channel identifier (`UC...`)
- **`channelHandle`** — the `@handle` form of the channel
- **`channelName`** — human-readable channel title
- **`channelDescription`** — full About description text
- **`subscriberCount`** — resolved subscriber count (matches YouTube's on-screen value)
- **`emails`** — deduplicated list of every email discovered for the channel
- **`sources`** — one entry per email with the exact URL and source type
- **`externalLinks`** — advertised links from the About page (not all are crawled)
- **`scrapedAt`** — ISO-8601 timestamp of this run

**Source types**

| `sourceType` | Where the email came from |
| --- | --- |
| `channel_description` | The channel's About description. |
| `channel_external_link` | An email embedded directly in an advertised link. |
| `instagram_bio` | Creator's Instagram profile (bio text or metadata). |
| `tiktok_bio` | Creator's TikTok profile. |
| `linktree` | A Linktree hub linked from the channel. |

**Error record** — emitted when a channel can't be parsed, so the run never fails entirely:

```json
{
  "type": "youtube_email_scraper_error",
  "reason": "fetch_failed",
  "message": "Could not fetch About page (blocked / offline / not found).",
  "channelUrl": "https://www.youtube.com/@SomeClosedChannel/about",
  "scrapedAt": "2026-04-24T12:00:00+00:00"
}
```

### Use cases

- **Influencer outreach** — build a ranked contact list for a shortlist of creators in a niche
- **Brand partnership research** — harvest business emails from your competitor's sponsored-creator roster
- **Agency sourcing** — quickly see which creators publish a reachable inbox vs. hide behind management
- **PR and press** — find the right email for an interview, quote, or product-review request
- **CRM enrichment** — keep your creator-contacts database synced with the emails currently advertised publicly

### FAQ

**Does this scraper bypass CAPTCHAs?**
No. The actor uses only the public About page and the public profile pages of Instagram, TikTok, and Linktree. When a page is fully blocked, the scraper emits an error record for that channel and moves on.

**Do I need cookies, a login, or a YouTube API key?**
No. The scraper is unauthenticated and reads only publicly available data.

**Will it find every email on a channel?**
It finds every email advertised in plain text, as a `mailto:` link, with common obfuscation (`[at]` / `[dot]`), and on linked Instagram / TikTok / Linktree bios. It cannot extract emails hidden behind YouTube's "View email address" click-to-reveal button — that gate requires a logged-in account and is not supported.

**Does it follow every external link on a channel?**
No — only Instagram, TikTok, and Linktree, because those are where creators most often advertise a contact address. All external links are still listed in `externalLinks` so you can follow them downstream if you wish.

**What if a channel has no public emails?**
The channel record is still emitted, just without the `emails` and `sources` fields. You can filter on the presence of `emails` in post-processing.

**How does the proxy fallback work?**
If a direct request returns a suspiciously small response or a known block page, the scraper transparently retries through Apify residential proxy. Set `autoProxyFallback: false` to skip the retry.

**How fast is it?**
Each channel typically takes under a second. Following external profiles adds one HTTP round-trip per profile (capped by `maxExternalPerChannel`).

### Known limitations

- **Click-to-reveal emails on YouTube are not supported.** YouTube's "View email address" button requires a logged-in session; this actor is login-free by design.
- **Instagram login walls** occasionally show for certain regions or IP ranges. When this happens the scraper skips that bio and keeps the emails it already found elsewhere.
- **TikTok region restrictions** can replace a profile with an interstitial page; the scraper still extracts whatever metadata the interstitial exposes.
- **Channels without a public About page** (some custom-branding and music-artist channels) return a `parse_failed` error record.
- **Subscriber counts** reflect YouTube's publicly displayed rounded value (e.g. `12K` → `12000`). Exact counts below YouTube's display threshold are not available.

# Actor input Schema

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

List of YouTube channel URLs to scan for contact emails. Supports @handle, /channel/UC..., /c/name, /user/name formats, and plain @handle shortcuts.

## `followExternalProfiles` (type: `boolean`):

When true, the scraper also opens external profile links advertised on the channel (Instagram, TikTok, Linktree) to discover emails hidden in their bios.

## `maxExternalPerChannel` (type: `integer`):

Upper bound on how many external profile URLs are fetched per channel (keeps runs cheap and predictable).

## `autoProxyFallback` (type: `boolean`):

Transparently retry a fetch via Apify residential proxy when the direct request looks like a block page (empty body or unusually small response). Saves credits by only using the proxy when needed.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Apify"
  ],
  "followExternalProfiles": true,
  "maxExternalPerChannel": 3,
  "autoProxyFallback": true
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/youtube-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"] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/youtube-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ]
}' |
apify call crawlerbros/youtube-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/youtube-email-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Email Scraper",
        "description": "Extract emails from YouTube channels without CAPTCHA bypass. Scans channel About descriptions and follows Instagram, TikTok and Linktree profiles linked from the channel. HTTP-only, no cookies, no API keys.",
        "version": "1.0",
        "x-build-id": "bxc7LTyOGfgzhAXUK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~youtube-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-youtube-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~youtube-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-youtube-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~youtube-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-youtube-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channelUrls"
                ],
                "properties": {
                    "channelUrls": {
                        "title": "YouTube channel URLs",
                        "type": "array",
                        "description": "List of YouTube channel URLs to scan for contact emails. Supports @handle, /channel/UC..., /c/name, /user/name formats, and plain @handle shortcuts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "followExternalProfiles": {
                        "title": "Follow external profiles (Instagram / TikTok / Linktree)",
                        "type": "boolean",
                        "description": "When true, the scraper also opens external profile links advertised on the channel (Instagram, TikTok, Linktree) to discover emails hidden in their bios.",
                        "default": true
                    },
                    "maxExternalPerChannel": {
                        "title": "Max external profiles followed per channel",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Upper bound on how many external profile URLs are fetched per channel (keeps runs cheap and predictable).",
                        "default": 3
                    },
                    "autoProxyFallback": {
                        "title": "Auto proxy fallback",
                        "type": "boolean",
                        "description": "Transparently retry a fetch via Apify residential proxy when the direct request looks like a block page (empty body or unusually small response). Saves credits by only using the proxy when needed.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```