# Youtube Channel Scraper (`scrapapi/youtube-channel-scraper`) Actor

Extract detailed data from YouTube channels using the YouTube Channel Scraper. Collect channel names, descriptions, subscriber counts, video counts, social links, and channel URLs automatically. Ideal for influencer discovery, marketing research, and creator outreach.

- **URL**: https://apify.com/scrapapi/youtube-channel-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (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

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Channel Scraper

The Youtube Channel Scraper is a production-ready Apify actor that extracts structured data from public YouTube channels — including About info, videos, Shorts, live streams, and community posts — with independent sorting per content type. Built for marketers, developers, data analysts, and researchers, this youtube channel scraping tool helps you scrape youtube channel videos, aggregate engagement metrics, and power analytics pipelines at scale.

### What data / output can you get?

Below are examples of real fields produced by the actor. Data is organized by channel username at the top level, with category arrays for videos, shorts, live, and posts.

| Data type | Description | Example value |
| --- | --- | --- |
| about.channelName | Channel’s display name | "MrBeast" |
| about.channelUsername | Channel handle (without @) | "MrBeast" |
| about.channelId | YouTube channel ID (externalId) | "UCX6OQ3DkcsbYNE6H8uQQuVA" |
| about.numberOfSubscribers | Subscriber count text | "453M" |
| about.channelTotalVideos | Total number of uploaded videos | 929 |
| about.channelTotalViews | Channel lifetime views | 102823749612 |
| about.channelJoinedDate | Channel join date | "Jan 2012" |
| about.channelLocation | Listed country/location | "United States" |
| about.channelAvatarUrl | Avatar image URL | "https://yt3.ggpht.com/..." |
| videos[].title | Video title | "100 Pilots Fight For A Private Jet" |
| videos[].viewCount | Parsed video views (int) | 50075792 |
| live[].isLive | Whether a stream is live | true |
| live[].scheduledStartTime | Scheduled start time (if upcoming) | "1736275200" |
| shorts[].viewsText | Shorts views text | "12M views" |
| shorts[].likesCount | Likes count (when available) | 34000 |
| shorts[].commentsCount | Comments count (when available) | 1200 |
| posts[].type | Post type: text/image/video/poll | "image" |
| posts[].likesCount | Estimated/accurate likes (enriched) | 440600 |
| posts[].commentsCount | Comments count (enriched when possible) | 3800 |

Notes:
- Each item includes URLs and thumbnails where applicable (e.g., videos[].url, shorts[].thumbnailUrl, posts[].postUrl).
- Bonus metadata includes ordering (order), source references (fromYTUrl, input), and various enrichment fields for shorts and live streams (e.g., shorts[].captionsAvailable, live[].liveChatId).
- Export your dataset as JSON, CSV, or Excel directly from the Apify platform for analytics and reporting (youtube channel data export csv).

### Key features

- 🔀 Independent sort orders per content type
  Configure separate sort orders for videos, Shorts, posts, and live streams to support workflows like a youtube video list scraper or youtube channel analytics scraper.

- ⚡ Asynchronous, concurrent fetching
  Efficiently crawl channels with up to 10 concurrent requests, automatic pagination, and robust retry logic — ideal for scaling a youtube channel crawler.

- 🛡️ Intelligent proxy fallback
  Starts without proxy, automatically falls back to datacenter proxy on blocks (403/429/503), and then to residential proxies — built for reliability.

- 🎯 Precise channel About extraction
  Captures channelName, channelId, subscriber counts, total views, join date, location, avatar/banner, description, and outbound links — great for a youtube channel id extractor and subscribers insights (youtube channel subscribers scraper).

- 🎥 Comprehensive content coverage
  Scrapes videos, Shorts, live streams, and community posts with structured engagement fields, including live stream status, scheduled times, and post poll options.

- 🧠 Developer-friendly, Python-based
  Built in Python on the Apify SDK, ready for API-driven pipelines and integrations. Perfect if you need a youtube channel scraper python workflow.

- 💾 Ready-to-use dataset
  Results are saved to an Apify dataset in real time, so you can export to JSON/CSV/Excel, feed BI tools, or pipe into automation platforms.

- 🧩 Workflow integration
  Use Apify’s API to orchestrate scheduled runs and downstream automation, e.g., pushing datasets into data warehouses or enrichment systems.

### How to use Youtube Channel Scraper - step by step

1) Sign in to your Apify account and open the actor.
2) Click Input and provide a list of channels in startUrls. You can paste:
   - Full URLs (e.g., https://www.youtube.com/@MrBeast)
   - Handles (e.g., @MrBeast)
   - Plain usernames (e.g., MrBeast)
3) Set maxResults to control how many items per category (videos/shorts/live/posts) you want.
4) Choose sorting preferences per content type:
   - sortOrderVideos, sortOrderShorts, sortOrderPosts, sortOrderLiveStreams
5) Toggle content types to scrape with scrapeChannelInfo, scrapeVideos, scrapeShorts, scrapePosts, scrapeLiveStreams.
6) Configure proxyConfiguration if needed. The actor starts without a proxy and falls back automatically when blocked.
7) Click Start. Monitor logs for progress, including any proxy fallbacks and totals per category.
8) When finished, open the Dataset tab to view results. Export as JSON, CSV, or Excel for analysis or ingestion.

Pro Tip: Orchestrate this youtube channel data scraper via the Apify API, then sync the data to your analytics stack or CRM for scheduled channel tracking.

### Use cases

| Use case | Description |
| --- | --- |
| Competitor analysis | Benchmark video cadence, live events, and community engagement to inform content strategy. |
| Influencer discovery | Filter by subscriber scale and content output to shortlist creators for outreach. |
| Market research | Track top channels in a niche and aggregate insights for trend reporting. |
| Analytics pipelines | Export structured data for dashboards and automated KPIs per channel segment. |
| Academic research | Collect multi-channel datasets for content, engagement, and growth studies. |
| API-driven workflows | Use the actor via API to feed enrichment, ETL, and reporting jobs at scale. |

### Why choose Youtube Channel Scraper?

A precise, automation-ready extractor for channel-level intelligence and content metadata.

- 🎯 Accuracy-first design: Extracts structured About info and robust content metadata across videos, Shorts, live, and posts.
- 🌍 Flexible sorting: Independent sort controls per content type to match your analysis needs.
- ⚙️ Built for developers: Python-based actor using the Apify SDK — easy to automate, integrate, and scale.
- 🛡️ Reliable at scale: Automatic retries, pagination, and smart proxy fallback for consistent throughput.
- 💾 Easy exports: Download datasets as JSON/CSV/Excel and plug into BI tools or data lakes.
- 🔒 Public data only: Scrapes publicly available channel data; no login or cookies required.
- 🚀 Better than extensions: No unstable browser hacks — this is a production-grade backend scraper.

In short, it’s a dependable youtube channel scraping tool for structured, scalable, and integration-friendly data collection.

### Is it legal / ethical to use Youtube Channel Scraper?

Yes — when used responsibly. This actor scrapes publicly available YouTube channel data and does not access private or authenticated content.

Guidelines:
- Collect only public information and respect platform rate limits.
- Comply with applicable regulations (e.g., GDPR, CCPA) in your jurisdiction.
- Review and adhere to YouTube’s Terms of Service for your specific use case.
- Consult your legal team for edge cases or commercial redistribution scenarios.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast",
    "@PewDiePie"
  ],
  "maxResults": 50,
  "sortOrderVideos": "viewCount",
  "sortOrderShorts": "date",
  "sortOrderPosts": "date",
  "sortOrderLiveStreams": "date",
  "scrapeChannelInfo": true,
  "scrapeVideos": true,
  "scrapeShorts": true,
  "scrapePosts": true,
  "scrapeLiveStreams": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

All input parameters

- startUrls (array, required): List of YouTube channel URLs (e.g., https://www.youtube.com/@MrBeast), usernames (e.g., @MrBeast), or keywords to search for channels. Default: none.
- maxResults (integer, optional): Maximum number of results to scrape per category (videos, shorts, live streams, posts). Minimum: 1, Maximum: 1000. Default: 10.
- sortOrderVideos (string, optional): Sort order for videos. One of: date, rating, relevance, title, viewCount. Default: "date".
- sortOrderShorts (string, optional): Sort order for shorts. One of: date, rating, relevance, viewCount. Default: "date".
- sortOrderPosts (string, optional): Sort order for community posts. One of: date, relevance. Default: "date".
- sortOrderLiveStreams (string, optional): Sort order for live streams. One of: date, relevance, viewCount. Default: "date".
- scrapeChannelInfo (boolean, optional): Enable to scrape channel About information. Default: true.
- scrapeVideos (boolean, optional): Enable to scrape channel videos. Default: true.
- scrapeShorts (boolean, optional): Enable to scrape YouTube Shorts. Default: true.
- scrapePosts (boolean, optional): Enable to scrape community posts. Default: true.
- scrapeLiveStreams (boolean, optional): Enable to scrape live streams. Default: true.
- proxyConfiguration (object, optional): Choose proxies. The actor starts with no proxy, falls back to datacenter if blocked, then to residential if needed. Default prefill: {"useApifyProxy": false}.

Example JSON output

```json
{
  "scrapedAt": "2026-03-11T09:05:29.305Z",
  "totalChannels": 2,
  "maxResultsPerCategory": 50,
  "MrBeast": {
    "about": {
      "channelDescription": "We make videos...",
      "channelJoinedDate": "Jan 2012",
      "channelDescriptionLinks": [
        { "text": "Website", "url": "https://mrbeast.com" }
      ],
      "channelLocation": "United States",
      "channelUsername": "MrBeast",
      "channelAvatarUrl": "https://yt3.ggpht.com/...",
      "channelBannerUrl": "https://yt3.googleusercontent.com/...",
      "channelTotalVideos": 929,
      "channelTotalViews": 102823749612,
      "numberOfSubscribers": "453M",
      "isChannelVerified": true,
      "channelName": "MrBeast",
      "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
      "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
      "inputChannelUrl": "https://www.youtube.com/@MrBeast",
      "isAgeRestricted": false
    },
    "videos": [
      {
        "id": "8bMh8azh3CY",
        "title": "100 Pilots Fight For A Private Jet",
        "duration": "28:46",
        "channelName": "MrBeast",
        "channelUsername": "MrBeast",
        "channelUrl": "https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA",
        "date": "1 day ago",
        "url": "https://www.youtube.com/watch?v=8bMh8azh3CY",
        "viewCount": 50075792,
        "fromYTUrl": "https://www.youtube.com/@MrBeast/videos",
        "type": "video",
        "thumbnailUrl": "https://i.ytimg.com/vi/8bMh8azh3CY/hqdefault.jpg",
        "input": "https://www.youtube.com/@MrBeast",
        "order": 0
      }
    ],
    "shorts": [
      {
        "videoType": "shorts",
        "videoId": "abc123",
        "title": "Wild challenge!",
        "videoUrl": "https://www.youtube.com/shorts/abc123",
        "viewsText": "12M views",
        "thumbnailUrl": "https://i.ytimg.com/vi/abc123/hqdefault.jpg",
        "accessibilityText": "Wild challenge!, 12M views - Short play",
        "channelUsername": "MrBeast",
        "fromYTUrl": "https://www.youtube.com/@MrBeast/shorts",
        "input": "https://www.youtube.com/@MrBeast",
        "order": 0,
        "likesCount": 34000,
        "likesCountText": "34K",
        "commentsCount": 1200,
        "commentsCountText": "1,200 comments",
        "commentsTurnedOff": false,
        "viewCount": 12000000,
        "channelName": "MrBeast",
        "channelId": "UCX6OQ3DkcsbYNE6H8uQQuVA",
        "channelHandle": "@MrBeast",
        "publishDate": "2025-12-01",
        "description": "Behind the scenes...",
        "captionsAvailable": true,
        "timestampText": "2 weeks ago"
      }
    ],
    "live": [
      {
        "videoId": "live123",
        "title": "Live right now!",
        "description": "Join the stream",
        "thumbnailUrl": "https://i.ytimg.com/vi/live123/hqdefault.jpg",
        "videoUrl": "https://www.youtube.com/watch?v=live123",
        "channelName": "MrBeast",
        "channelUrl": "https://www.youtube.com/@MrBeast",
        "publishedAt": "Streamed 1 hour ago",
        "duration": "LIVE",
        "viewsCount": 56000,
        "viewsCountText": "56,000 watching now",
        "isLive": true,
        "isUpcoming": false,
        "scheduledStartTime": "",
        "order": 0,
        "actualStartTime": "2026-03-11T08:00:00Z",
        "liveChatId": "CiQKFkdFRVJZc2FQb29s...",
        "concurrentViewers": "56,000 watching",
        "isLiveNow": true
      }
    ],
    "posts": [
      {
        "postId": "post123",
        "type": "image",
        "textContent": "Sneak peek 👀",
        "imageUrls": ["https://i.ytimg.com/vi/post123/image.jpg"],
        "pollOptions": [],
        "likesCount": 440600,
        "likesCountText": "440,600",
        "commentsCount": 3800,
        "commentsCountText": "3,800 comments",
        "publishedAt": "2 days ago",
        "postUrl": "https://www.youtube.com/post/post123",
        "channelName": "MrBeast",
        "channelUrl": "https://www.youtube.com/@MrBeast",
        "order": 0
      }
    ],
    "stats": {
      "totalVideos": 50,
      "totalShorts": 50,
      "totalLiveStreams": 38,
      "totalPosts": 50,
      "scrapingTimeSeconds": 42.15
    }
  },
  "summary": {
    "totalVideos": 100,
    "totalShorts": 50,
    "totalLiveStreams": 38,
    "totalPosts": 96,
    "totalScrapingTimeSeconds": 84.3
  }
}
```

Notes:

- Top-level keys are the channel usernames (e.g., "MrBeast"), each containing about, videos, shorts, live, posts, and stats.
- Some enrichment fields may be null or absent if not available on the source pages.

### FAQ

#### Do I need the official YouTube API to use this?

No. The actor scrapes publicly available YouTube pages and endpoints, so you can scrape youtube channel without api while still collecting structured channel and content data.

#### What channel data does it return?

It returns About metadata (name, id, subscribers, total views, join date, location, description, avatar/banner, external links) plus videos, Shorts, live streams, and community posts with engagement fields. See the Output section for exact JSON fields.

#### Can I export results to CSV or Excel?

Yes. After a run, open the Dataset and use Apify’s built‑in export to download JSON, CSV, or Excel. This supports youtube channel data export csv workflows and BI pipelines.

#### How many items per channel can I collect?

Use maxResults to set the maximum per category (videos, shorts, live, posts). The scraper paginates until it reaches your limit or runs out of items.

#### Does it scrape comments?

It does not scrape full comment threads. However, it captures commentsCount and likesCount for Shorts when available, and enriches community posts with likesCount and commentsCount when possible.

#### How does proxy handling work?

The actor starts with no proxy. If a request is blocked (e.g., 403/429/503), it falls back to a datacenter proxy, and then to a residential proxy if needed. This improves reliability for large-scale runs.

#### Can I use it programmatically with Python or an API?

Yes. This is a Python-based Apify actor and can be triggered via the Apify API, making it easy to integrate into pipelines or a youtube channel scraper python workflow.

#### Does it support playlists or RSS feeds?

No. The current scope focuses on channel About info, videos, Shorts, live streams, and community posts. If you need a youtube playlist scraper or youtube channel rss feed scraper, contact the author for a custom solution.

### Closing CTA / Final thoughts

The Youtube Channel Scraper is built for reliable, structured extraction of YouTube channel intelligence and content metadata. With independent sort controls, smart proxy fallback, and async pagination, it’s ideal for marketers, developers, analysts, and researchers. Run it on Apify, export to CSV/JSON/Excel, and integrate via API to power your analytics and automation. Start extracting smarter channel insights at scale today.

# Actor input Schema

## `startUrls` (type: `array`):

List of YouTube channel URLs (e.g., https://www.youtube.com/@MrBeast), usernames (e.g., @MrBeast), or keywords to search for channels.

## `maxResults` (type: `integer`):

Maximum number of results to scrape per category (videos, shorts, live streams, posts).

## `sortOrderVideos` (type: `string`):

Sort order for videos (date, rating, relevance, title, viewCount).

## `sortOrderShorts` (type: `string`):

Sort order for shorts (date, rating, relevance, viewCount).

## `sortOrderPosts` (type: `string`):

Sort order for community posts (date, relevance).

## `sortOrderLiveStreams` (type: `string`):

Sort order for live streams (date, relevance, viewCount).

## `scrapeChannelInfo` (type: `boolean`):

Enable to scrape channel about information (description, subscribers, join date, etc.).

## `scrapeVideos` (type: `boolean`):

Enable to scrape channel videos.

## `scrapeShorts` (type: `boolean`):

Enable to scrape YouTube Shorts.

## `scrapePosts` (type: `boolean`):

Enable to scrape community posts.

## `scrapeLiveStreams` (type: `boolean`):

Enable to scrape live streams.

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

Choose which proxies to use. The actor will start with no proxy, fallback to datacenter proxy if blocked, then to residential proxy if datacenter fails.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast"
  ],
  "maxResults": 10,
  "sortOrderVideos": "date",
  "sortOrderShorts": "date",
  "sortOrderPosts": "date",
  "sortOrderLiveStreams": "date",
  "scrapeChannelInfo": true,
  "scrapeVideos": true,
  "scrapeShorts": true,
  "scrapePosts": true,
  "scrapeLiveStreams": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.youtube.com/@MrBeast"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/youtube-channel-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 = {
    "startUrls": ["https://www.youtube.com/@MrBeast"],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Channel Scraper",
        "description": "Extract detailed data from YouTube channels using the YouTube Channel Scraper. Collect channel names, descriptions, subscriber counts, video counts, social links, and channel URLs automatically. Ideal for influencer discovery, marketing research, and creator outreach.",
        "version": "0.1",
        "x-build-id": "4ZdAm1ExdRIudmVSf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~youtube-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-youtube-channel-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/scrapapi~youtube-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-youtube-channel-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/scrapapi~youtube-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-youtube-channel-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Channel URLs, Usernames, or Keywords",
                        "type": "array",
                        "description": "List of YouTube channel URLs (e.g., https://www.youtube.com/@MrBeast), usernames (e.g., @MrBeast), or keywords to search for channels.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results Per Category",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of results to scrape per category (videos, shorts, live streams, posts).",
                        "default": 10
                    },
                    "sortOrderVideos": {
                        "title": "Sort Order for Videos",
                        "enum": [
                            "date",
                            "rating",
                            "relevance",
                            "title",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "Sort order for videos (date, rating, relevance, title, viewCount).",
                        "default": "date"
                    },
                    "sortOrderShorts": {
                        "title": "Sort Order for Shorts",
                        "enum": [
                            "date",
                            "rating",
                            "relevance",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "Sort order for shorts (date, rating, relevance, viewCount).",
                        "default": "date"
                    },
                    "sortOrderPosts": {
                        "title": "Sort Order for Posts",
                        "enum": [
                            "date",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for community posts (date, relevance).",
                        "default": "date"
                    },
                    "sortOrderLiveStreams": {
                        "title": "Sort Order for Live Streams",
                        "enum": [
                            "date",
                            "relevance",
                            "viewCount"
                        ],
                        "type": "string",
                        "description": "Sort order for live streams (date, relevance, viewCount).",
                        "default": "date"
                    },
                    "scrapeChannelInfo": {
                        "title": "Scrape Channel Information",
                        "type": "boolean",
                        "description": "Enable to scrape channel about information (description, subscribers, join date, etc.).",
                        "default": true
                    },
                    "scrapeVideos": {
                        "title": "Scrape Videos",
                        "type": "boolean",
                        "description": "Enable to scrape channel videos.",
                        "default": true
                    },
                    "scrapeShorts": {
                        "title": "Scrape Shorts",
                        "type": "boolean",
                        "description": "Enable to scrape YouTube Shorts.",
                        "default": true
                    },
                    "scrapePosts": {
                        "title": "Scrape Community Posts",
                        "type": "boolean",
                        "description": "Enable to scrape community posts.",
                        "default": true
                    },
                    "scrapeLiveStreams": {
                        "title": "Scrape Live Streams",
                        "type": "boolean",
                        "description": "Enable to scrape live streams.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. The actor will start with no proxy, fallback to datacenter proxy if blocked, then to residential proxy if datacenter fails."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
