# YouTube Scraper — Channels, Videos & Creator Leads (`scrapesage/youtube-scraper`) Actor

Scrape YouTube: search channels & videos by keyword, full channel profiles, video details, plus creator-contact leads (emails, phones, socials from the channel's own website). Subscribers, views, links, monitoring. No login, no API key, no browser.

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

## Pricing

from $7.00 / 1,000 channel scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 Scraper — Channels, Videos & Creator Leads (Subscribers, Emails & Socials)

Extract **complete YouTube channel and video data** — and turn any channel into a **ready-to-contact creator lead**. Search channels or videos by keyword, pull full channel profiles (subscribers, total views, video count, joined date, country, keywords, verified status, all external links) and full video metadata (views, likes, comments, tags, duration), then optionally crawl each channel's own website for **contact emails, phone numbers, and social links**.

No login, no API key, no browser — fast JSON extraction straight from YouTube's own public web endpoints.

### Why this YouTube scraper?

Most YouTube scrapers either return a thin video list or stop at the public channel card. This actor ships the **richest dataset in the category** and is built for **influencer marketing, sponsorship prospecting, and creator lead generation**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Channel subscribers / total views / video count | partial | ✅ exact + parsed integers |
| Channel description, country, joined date, keywords | ❌ | ✅ |
| Channel external links (website + every social) | ❌ | ✅ decoded |
| Creator **contact emails** (from their website) | ❌ | ✅ opt-in |
| Creator phone + LinkedIn / Instagram / TikTok / X | ❌ | ✅ opt-in |
| Business-email availability flag | ❌ | ✅ |
| Lead score (0–100) per channel | ❌ | ✅ |
| Verified badge, family-safe, available countries | ❌ | ✅ |
| Video views / likes / comments / tags / category | partial | ✅ |
| Channel activity (last upload, active/dormant) | ❌ | ✅ opt-in |
| Monitoring — only new channels/videos | ❌ | ✅ |

### Use cases

- **Influencer & creator lead generation** — YouTubers are active buyers and sellers: they need sponsors, editors, gear, courses, agencies, and tools. Find them by keyword, score them by reach (`subscriberCount`, `viewCount`) and activity, and contact them directly (`contactEmails`, `socialLinks`).
- **Sponsorship & brand-deal prospecting** — build lists of creators in any niche (real estate, fitness, finance, gaming, beauty, B2B SaaS) with audience size and verified contact data.
- **Influencer marketing agencies** — source and qualify creators at scale; enrich with website emails and socials for outreach.
- **Competitor & market intelligence** — track channels and videos in your space: views, upload cadence, top-performing topics, growth signals.
- **Content & trend research** — pull the top videos for any keyword, sorted by views or recency, with full metadata.
- **Monitoring** — schedule recurring runs to capture only new channels for a search, or only new videos from the creators you track.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **YouTube Scraper**, pick a **mode**, enter search terms (or paste channel/video URLs), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "searchChannels",
    "searchTerms": ["real estate coach", "home fitness"],
    "maxResultsPerQuery": 50,
    "includeVideos": true,
    "maxVideosPerChannel": 10,
    "enrichCreatorContacts": true,
    "country": "US",
    "language": "en"
}
````

#### Modes

- **Search channels** — find channels by keyword and return full profiles (the discovery + lead engine). Optionally include each channel's recent videos and crawl websites for contacts.
- **Channel details** — pull full profiles for specific channels you already know. Accepts `@handles`, channel URLs (`/channel/UC...`, `/c/...`, `/user/...`), or raw channel IDs.
- **Search videos** — find videos by keyword, sorted by relevance, upload date, views, or rating.
- **Video details** — pull full metadata for specific videos (watch URLs, `youtu.be` links, Shorts URLs, or 11-character IDs), including likes and comments.

#### Key options

- **searchTerms** — keywords for the search modes (one row per term).
- **channelUrls / videoUrls** — specific channels / videos for the detail modes.
- **maxResultsPerQuery** *(default 30)* — channels or videos per term; paginated automatically.
- **videoSort** — relevance / date / views / rating (Search videos).
- **includeVideos** *(default false)* — also output recent video records per channel and derive an activity signal.
- **maxVideosPerChannel** *(default 10)* — how many recent videos to pull per channel.
- **includeVideoStats** *(default false)* — fetch like/comment counts, tags and exact publish dates for videos (one extra request per video).
- **enrichCreatorContacts** *(default false)* — crawl each channel's own website (home + contact/about) for emails, phone, and extra socials. YouTube hides the business email behind a CAPTCHA — this is the reliable way to get a contact.
- **country / language** — region and UI language for results.
- **monitorMode** *(default false)* — emit only records not seen in previous runs (pairs with Schedules).

### Output

One record per channel (`type: "channel"`), plus optional video records (`type: "video"`):

```json
{
    "type": "channel",
    "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
    "handle": "@MrBeast",
    "title": "MrBeast",
    "description": "SUBSCRIBE FOR A COOKIE!",
    "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
    "subscriberCount": 501000000,
    "subscriberCountText": "501M subscribers",
    "videoCount": 987,
    "viewCount": 129036823441,
    "joinedDate": "2012-02-19T00:00:00.000Z",
    "country": "United States",
    "keywords": ["mrbeast", "beast", "challenge"],
    "isVerified": true,
    "businessEmailAvailable": true,
    "avatarUrl": "https://yt3.ggpht.com/...",
    "website": "https://shopmrbeast.com",
    "socialLinks": {
        "instagram": "https://www.instagram.com/mrbeast/",
        "twitter": "https://twitter.com/MrBeast",
        "facebook": "https://facebook.com/mrbeast/"
    },
    "externalLinks": [
        { "title": "Follow", "url": "https://www.instagram.com/mrbeast/", "type": "instagram" }
    ],
    "contactEmails": ["business@example.com"],
    "contactPhones": ["+1 212 555 0134"],
    "descriptionEmails": [],
    "isActive": true,
    "daysSinceLastVideo": 3,
    "leadScore": 92,
    "source": "searchChannels",
    "query": "challenges",
    "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

Video records carry `videoId`, `url`, `title`, `channelTitle`, `viewCount`, `likeCount`, `commentCount`, `publishedDate`, `publishedTimeText`, `lengthSeconds`, `durationFormatted`, `category`, `tags`, `thumbnailUrl`, and more.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily/weekly to monitor new channels in a niche or new videos from tracked creators; perfect for lead pipelines and content alerts.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/youtube-scraper').call({
    mode: 'searchChannels',
    searchTerms: ['b2b marketing'],
    maxResultsPerQuery: 50,
    enrichCreatorContacts: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} channels & creator leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new creator leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new channels.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find fitness YouTubers with over 100k subscribers and list their contact emails" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **creator & lead-gen stack**:

- **[Telegram Scraper](https://apify.com/scrapesage/telegram-scraper)** — channels, messages, media and search across Telegram.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence across Meta & Instagram.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google & YouTube.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads (emails, socials, prices).
- **[Whova Event Scraper](https://apify.com/scrapesage/whova-event-scraper)** — attendees, agendas and sponsors from event apps.
- **[Swapcard Exhibitor Scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper)** — exhibitor and speaker leads from trade shows.
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — sessions and speakers from conference sites.

### Tips

- **Find creators with contacts**: run **Search channels** with `enrichCreatorContacts` on, then sort the dataset by `leadScore` (descending) to surface the most contactable, highest-reach channels first.
- **Niche down**: use specific search terms (`vegan meal prep`, `commercial real estate`, `indie game dev`) rather than broad ones — you'll get more relevant channels per result.
- **Exhaust a topic**: raise `maxResultsPerQuery` and add several related `searchTerms`; YouTube search paginates deep but eventually repeats, so multiple narrow terms beat one broad term.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to capture only new channels for a search, or only new uploads from creators you track.
- **Proxies**: the default Apify proxy is enough; switch to residential for very large or high-frequency runs to avoid rate limits.

### FAQ

**Where do the creator emails come from?** Never from a hidden YouTube field. YouTube puts the channel's "business email" behind a CAPTCHA, so it isn't machine-readable — `businessEmailAvailable` only tells you whether one exists. With `enrichCreatorContacts` on, the actor visits the channel's own public website (the link the creator lists on their About page) and extracts the contact emails, phones, and socials a human visitor would see, plus any emails written in the channel description.

**How do I scrape a specific channel?** Use **Channel details** and paste the `@handle`, the channel URL, or the channel ID into `channelUrls`. Legacy `/c/` and `/user/` URLs work too.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new videos automatically?** Turn on `monitorMode`, add the channels to `channelUrls` with `includeVideos`, and create a [Schedule](https://docs.apify.com/platform/schedules). Each run returns only the new uploads since the last one.

**Does it need the official YouTube Data API or a key?** No. This actor reads YouTube's own public web endpoints — no API key, no quota, no login.

**Is scraping YouTube legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (GDPR/CCPA for personal data) and YouTube's terms.

**A field is null — why?** Some channels don't list a website, country, or links; some videos hide their like or comment counts. Fields are `null` only when the data isn't public, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `mode` (type: `string`):

Pick a job. Search channels finds channels by keyword (with full profiles + leads). Channel details pulls full profiles for specific channels. Search videos finds videos by keyword. Video details pulls full metadata for specific videos.

## `searchTerms` (type: `array`):

Keywords to search YouTube for, e.g. `real estate coach`, `b2b marketing`, `home fitness`. One row per term. Used by the Search channels and Search videos modes.

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

Channels to pull full details for: @handles (`@MrBeast`), channel URLs (`youtube.com/@MrBeast`, `/channel/UC...`, `/c/...`, `/user/...`), or raw channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`). One per row. (Mode: Channel details.)

## `videoUrls` (type: `array`):

Videos to pull full metadata for: watch URLs (`youtube.com/watch?v=...`), short URLs (`youtu.be/...`), Shorts URLs, or raw 11-character video IDs. One per row. (Mode: Video details.)

## `maxResultsPerQuery` (type: `integer`):

Cap the number of channels (or videos) returned per search term. Results are paginated automatically until this limit or the result set is exhausted.

## `videoSort` (type: `string`):

Order for the Search videos mode.

## `includeVideos` (type: `boolean`):

For channel modes, also output recent video records (type `video`) from each channel — title, views, published time, duration and more. Also derives an activity signal (last upload, active/dormant). In monitoring mode this returns only NEW videos since the last run.

## `maxVideosPerChannel` (type: `integer`):

How many recent videos to pull per channel when 'Include channel videos' is on.

## `includeVideoStats` (type: `boolean`):

For video modes, fetch each video's full metadata including like and comment counts, tags and exact publish date (one extra request per video). Search videos returns lightweight cards unless this is on.

## `enrichCreatorContacts` (type: `boolean`):

Opt-in lead enrichment: visit each channel's own public website (home + a contact/about page) and extract contact emails, phone numbers and social links — for influencer outreach, sponsorship and B2B prospecting. Only runs for channels that list a website.

## `country` (type: `string`):

Two-letter region code (e.g. `US`, `GB`, `DE`, `AU`) for search results and rankings.

## `language` (type: `string`):

Two-letter UI language code (e.g. `en`, `de`, `es`) for titles and labels.

## `monitorMode` (type: `boolean`):

Remember what was already returned and emit ONLY records not seen in previous runs (new channels for a search, new videos per channel, or new videos for a search). Pairs with Apify Schedules to track changes over time.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the 'already seen' ids for monitoring mode. Use a different name per tracked target/query to keep their histories separate.

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

Maximum parallel requests. Lower it if you hit rate limits on very large runs.

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

Proxy settings. YouTube's public web endpoints work fine through the default Apify datacenter proxy; switch to residential for very large or high-frequency runs to avoid rate limits.

## Actor input object example

```json
{
  "mode": "searchChannels",
  "searchTerms": [
    "real estate coach"
  ],
  "maxResultsPerQuery": 30,
  "videoSort": "relevance",
  "includeVideos": false,
  "maxVideosPerChannel": 10,
  "includeVideoStats": false,
  "enrichCreatorContacts": false,
  "country": "US",
  "language": "en",
  "monitorMode": false,
  "monitorStoreName": "youtube-monitor",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Channel rows carry full profile data, external links and creator-contact leads; video rows carry their own metadata.

# 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 = {
    "searchTerms": [
        "real estate coach"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/youtube-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 = { "searchTerms": ["real estate coach"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/youtube-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 '{
  "searchTerms": [
    "real estate coach"
  ]
}' |
apify call scrapesage/youtube-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Scraper — Channels, Videos & Creator Leads",
        "description": "Scrape YouTube: search channels & videos by keyword, full channel profiles, video details, plus creator-contact leads (emails, phones, socials from the channel's own website). Subscribers, views, links, monitoring. No login, no API key, no browser.",
        "version": "0.1",
        "x-build-id": "Nk5zBsfXO3pj2EfmL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~youtube-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-youtube-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/scrapesage~youtube-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-youtube-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/scrapesage~youtube-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-youtube-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "searchChannels",
                            "channelDetails",
                            "searchVideos",
                            "videoDetails"
                        ],
                        "type": "string",
                        "description": "Pick a job. Search channels finds channels by keyword (with full profiles + leads). Channel details pulls full profiles for specific channels. Search videos finds videos by keyword. Video details pulls full metadata for specific videos.",
                        "default": "searchChannels"
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search YouTube for, e.g. `real estate coach`, `b2b marketing`, `home fitness`. One row per term. Used by the Search channels and Search videos modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "Channel handles / URLs / IDs",
                        "type": "array",
                        "description": "Channels to pull full details for: @handles (`@MrBeast`), channel URLs (`youtube.com/@MrBeast`, `/channel/UC...`, `/c/...`, `/user/...`), or raw channel IDs (`UCX6OQ3DkcsbYNE6H8uQQuVA`). One per row. (Mode: Channel details.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "videoUrls": {
                        "title": "Video URLs / IDs",
                        "type": "array",
                        "description": "Videos to pull full metadata for: watch URLs (`youtube.com/watch?v=...`), short URLs (`youtu.be/...`), Shorts URLs, or raw 11-character video IDs. One per row. (Mode: Video details.)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search term",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Cap the number of channels (or videos) returned per search term. Results are paginated automatically until this limit or the result set is exhausted.",
                        "default": 30
                    },
                    "videoSort": {
                        "title": "Sort videos by",
                        "enum": [
                            "relevance",
                            "date",
                            "views",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Order for the Search videos mode.",
                        "default": "relevance"
                    },
                    "includeVideos": {
                        "title": "Include channel videos",
                        "type": "boolean",
                        "description": "For channel modes, also output recent video records (type `video`) from each channel — title, views, published time, duration and more. Also derives an activity signal (last upload, active/dormant). In monitoring mode this returns only NEW videos since the last run.",
                        "default": false
                    },
                    "maxVideosPerChannel": {
                        "title": "Max videos per channel",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many recent videos to pull per channel when 'Include channel videos' is on.",
                        "default": 10
                    },
                    "includeVideoStats": {
                        "title": "Include full video stats (likes, comments)",
                        "type": "boolean",
                        "description": "For video modes, fetch each video's full metadata including like and comment counts, tags and exact publish date (one extra request per video). Search videos returns lightweight cards unless this is on.",
                        "default": false
                    },
                    "enrichCreatorContacts": {
                        "title": "Enrich creator contacts (crawl website for emails, phone, socials)",
                        "type": "boolean",
                        "description": "Opt-in lead enrichment: visit each channel's own public website (home + a contact/about page) and extract contact emails, phone numbers and social links — for influencer outreach, sponsorship and B2B prospecting. Only runs for channels that list a website.",
                        "default": false
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter region code (e.g. `US`, `GB`, `DE`, `AU`) for search results and rankings.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter UI language code (e.g. `en`, `de`, `es`) for titles and labels.",
                        "default": "en"
                    },
                    "monitorMode": {
                        "title": "Monitoring mode — only new records",
                        "type": "boolean",
                        "description": "Remember what was already returned and emit ONLY records not seen in previous runs (new channels for a search, new videos per channel, or new videos for a search). Pairs with Apify Schedules to track changes over time.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the 'already seen' ids for monitoring mode. Use a different name per tracked target/query to keep their histories separate.",
                        "default": "youtube-monitor"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower it if you hit rate limits on very large runs.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. YouTube's public web endpoints work fine through the default Apify datacenter proxy; switch to residential for very large or high-frequency runs to avoid rate limits.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
