# YouTube Sponsorship Lead Scraper (`ramman/youtube-sponsorship-lead-scraper`) Actor

Discover YouTube creator leads instantly. Extract business emails, websites, social links, subscriber counts, and recent video performance data. Ideal for influencer marketing, outreach campaigns, sponsorship prospecting, and creator lead generation.

- **URL**: https://apify.com/ramman/youtube-sponsorship-lead-scraper.md
- **Developed by:** [ramman](https://apify.com/ramman) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

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

### What does YouTube Sponsorship Lead Scraper do?

**YouTube Sponsorship Lead Scraper** helps brands, agencies, and marketers discover **YouTube creators** and collect **sponsorship contact information** in structured JSON. Search by niche keywords to find new channels, or paste known channel URLs to enrich your prospect list with business email, website, social links, subscriber counts, and latest video performance.

The Actor runs on [Apify](https://apify.com) so you can schedule runs, export datasets, integrate via API, and scale with proxy rotation when needed. Data is extracted from [YouTube](https://www.youtube.com) channel About and Videos pages using Playwright and Crawlee.

It supports three email extraction layers:

1. **Public description** — emails written directly in the channel description
2. **About page parsing** — emails found in YouTube page data and visible About text
3. **View email address reveal** — clicks YouTube's official reveal button when you supply logged-in session cookies

### Why use YouTube Sponsorship Lead Scraper?

- **Outreach-ready leads** — Collect business emails and social profiles used for sponsorship inquiries
- **Two discovery modes** — Keyword search or direct channel URL lists
- **Gated email support** — Optional YouTube session cookies to reveal emails behind **View email address**
- **Performance context** — Latest video title, URL, and view count per creator
- **Audience filtering** — Skip channels below your minimum subscriber threshold
- **Production-ready** — Retries, logging, typed dataset output, and Apify export formats

### How to use YouTube Sponsorship Lead Scraper

1. Open the Actor in [Apify Console](https://console.apify.com) and go to the **Input** tab.
2. Choose your mode:
   - **Keyword search** — Add keywords such as `gaming`, `beauty`, or `tech reviews`
   - **Channel URLs** — Paste links like `https://www.youtube.com/@mkbhd`
3. Set **Max Channels** and **Minimum Subscribers** to control volume and quality.
4. *(Optional)* Add **YouTube Session Cookies** if you need emails behind **View email address**.
5. Click **Start** and wait for the run to finish.
6. Download results from the **Dataset** tab as JSON, CSV, Excel, or HTML.

#### Example input (keyword mode)

```json
{
  "keywords": ["gaming"],
  "channelUrls": [],
  "maxChannels": 100,
  "minSubscribers": 1000
}
````

#### Example input (channel URL mode)

```json
{
  "keywords": [],
  "channelUrls": [
    "https://www.youtube.com/@mkbhd",
    "https://www.youtube.com/@LinusTechTips"
  ],
  "maxChannels": 50,
  "minSubscribers": 0
}
```

#### Example input (with email reveal cookies)

```json
{
  "keywords": [],
  "channelUrls": ["https://www.youtube.com/@OpTicGaming"],
  "maxChannels": 10,
  "minSubscribers": 0,
  "youtubeSessionCookies": "SID=...; HSID=...; SSID=...; APISID=...; SAPISID=..."
}
```

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `keywords` | string\[] | `["gaming"]` | Keywords for YouTube channel search (one search per keyword) |
| `channelUrls` | string\[] | `[]` | Direct YouTube channel URLs (`@handle`, `/channel/ID`, `/c/`, `/user/`) |
| `maxChannels` | integer | `100` | Maximum channels saved to the dataset (1–1000) |
| `minSubscribers` | integer | `1000` | Skip channels below this subscriber count |
| `proxyConfiguration` | object | Apify Proxy off | Optional proxy settings for blocked regions or IPs |
| `youtubeSessionCookies` | string | empty | Logged-in YouTube cookies to reveal gated business emails |

Provide at least one keyword or channel URL.

#### How to get YouTube session cookies

1. Log in to [YouTube](https://www.youtube.com) in Chrome.
2. Open DevTools → **Application** → **Cookies** → `https://www.youtube.com`.
3. Copy values for `SID`, `HSID`, `SSID`, `APISID`, and `SAPISID`.
4. Paste as: `SID=...; HSID=...; SSID=...; APISID=...; SAPISID=...`

Store cookies in Apify **Secrets** when running in production. Cookies expire and should be refreshed periodically.

### Output

Each dataset item is a sponsorship lead:

```json
{
  "channelName": "Marques Brownlee",
  "channelUrl": "https://www.youtube.com/@mkbhd",
  "channelHandle": "@mkbhd",
  "subscriberCount": "21,000,000",
  "businessEmail": "business@mkbhd.com",
  "website": "https://example.com",
  "instagramUrl": "https://instagram.com/MKBHD",
  "twitterUrl": "https://twitter.com/MKBHD",
  "facebookUrl": "",
  "latestVideoTitle": "The Most Interesting Displays In The World!",
  "latestVideoUrl": "https://www.youtube.com/watch?v=WOzcFkld6_g",
  "latestVideoViews": "1.8M"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Description |
| --- | --- |
| `channelName` | Display name of the YouTube channel |
| `channelUrl` | Canonical channel URL |
| `channelHandle` | @handle or channel ID segment |
| `subscriberCount` | Formatted subscriber count |
| `businessEmail` | Business/contact email when publicly visible or revealed via session cookies |
| `website` | First external non-social link on the About page |
| `instagramUrl` | Instagram profile URL |
| `twitterUrl` | Twitter/X profile URL |
| `facebookUrl` | Facebook page/profile URL |
| `latestVideoTitle` | Title of the most recent uploaded video |
| `latestVideoUrl` | URL of the latest video |
| `latestVideoViews` | View count text for the latest video |

### Pricing / Cost estimation

Cost depends on how many channels you scrape. Each channel typically requires two browser page loads (About + Videos). Keyword mode adds one search request per keyword.

Approximate guidance:

- **10 channels** — Low cost, good for testing output quality
- **100 channels** — Moderate cost for campaign prospecting
- **500+ channels** — Use `maxChannels`, enable proxy only if blocked, schedule off-peak runs

Apify free tier includes monthly platform credits. Monitor usage in Apify Console under **Billing**.

### Tips or Advanced options

- Start with `maxChannels: 5–10` to validate output for your niche before scaling.
- Use **Channel URL mode** when you already have a prospect list from another tool.
- Increase `minSubscribers` to focus on mid-tier or macro creators.
- Enable **Apify Proxy** if YouTube shows consent pages or blocks datacenter IPs.
- Use **YouTube Session Cookies** only when you need emails behind **View email address** — many channels already list email in the description.
- Combine related keywords (`fitness`, `home workout`, `gym`) to broaden discovery within a vertical.

### FAQ, disclaimers, and support

**Is scraping YouTube legal?**\
You are responsible for complying with YouTube's Terms of Service, applicable laws, and data protection rules in your jurisdiction. Use scraped contact data for legitimate business outreach only.

**Why is business email empty?**\
Common reasons:

- The creator did not publish a business email on YouTube
- The email is behind **Sign in to see email address** — add **YouTube Session Cookies** so the Actor can click **View email address**
- The email is only on an external website, not on YouTube itself

**What is the difference between public email and View email address?**\
Some creators write their email in the channel description (always extractable). Others use YouTube's gated **View email address** button, which requires a logged-in session. Supply `youtubeSessionCookies` for those channels.

**Known limitations**

- Gated emails require valid, logged-in YouTube session cookies
- Only contact details visible on YouTube About/Videos pages are extracted
- YouTube layout changes may affect field availability; the Actor uses resilient JSON parsing with retries
- Subscriber and view counts are stored as displayed text/formatted values
- TikTok, Discord, and similar links may appear in `website` when no dedicated website is listed

For feedback or feature requests, open an issue from the Actor's **Issues** tab in Apify Console.

# Actor input Schema

## `keywords` (type: `array`):

Keywords used to discover YouTube channels. Each keyword runs a channel-filtered YouTube search.

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

Direct YouTube channel URLs to scrape (e.g. https://www.youtube.com/@mkbhd). Use this mode when you already know which creators to target.

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

Maximum number of channels to scrape and save to the dataset.

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

Skip channels with fewer subscribers than this threshold.

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

Apify Proxy settings. Enable proxies if YouTube blocks requests from your region or IP.

## `youtubeSessionCookies` (type: `string`):

Optional logged-in YouTube cookies (e.g. SID=...; HSID=...; SSID=...; APISID=...; SAPISID=...). Required to reveal emails hidden behind YouTube's "View email address" button. Leave empty to only extract publicly visible emails.

## Actor input object example

```json
{
  "keywords": [
    "gaming"
  ],
  "channelUrls": [],
  "maxChannels": 100,
  "minSubscribers": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "youtubeSessionCookies": ""
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "gaming"
    ],
    "channelUrls": [],
    "youtubeSessionCookies": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("ramman/youtube-sponsorship-lead-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 = {
    "keywords": ["gaming"],
    "channelUrls": [],
    "youtubeSessionCookies": "",
}

# Run the Actor and wait for it to finish
run = client.actor("ramman/youtube-sponsorship-lead-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 '{
  "keywords": [
    "gaming"
  ],
  "channelUrls": [],
  "youtubeSessionCookies": ""
}' |
apify call ramman/youtube-sponsorship-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Sponsorship Lead Scraper",
        "description": "Discover YouTube creator leads instantly. Extract business emails, websites, social links, subscriber counts, and recent video performance data. Ideal for influencer marketing, outreach campaigns, sponsorship prospecting, and creator lead generation.",
        "version": "1.0",
        "x-build-id": "FzBhdBQlq6muK3z2L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ramman~youtube-sponsorship-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ramman-youtube-sponsorship-lead-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/ramman~youtube-sponsorship-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ramman-youtube-sponsorship-lead-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/ramman~youtube-sponsorship-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ramman-youtube-sponsorship-lead-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",
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords used to discover YouTube channels. Each keyword runs a channel-filtered YouTube search.",
                        "default": [
                            "gaming"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "Direct YouTube channel URLs to scrape (e.g. https://www.youtube.com/@mkbhd). Use this mode when you already know which creators to target.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxChannels": {
                        "title": "Max Channels",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of channels to scrape and save to the dataset.",
                        "default": 100
                    },
                    "minSubscribers": {
                        "title": "Minimum Subscribers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip channels with fewer subscribers than this threshold.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Enable proxies if YouTube blocks requests from your region or IP.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "youtubeSessionCookies": {
                        "title": "YouTube Session Cookies",
                        "type": "string",
                        "description": "Optional logged-in YouTube cookies (e.g. SID=...; HSID=...; SSID=...; APISID=...; SAPISID=...). Required to reveal emails hidden behind YouTube's \"View email address\" button. Leave empty to only extract publicly visible emails.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
