# Youtube Channel Video Scraper (`alpha-scraper/youtube-channel-video-scraper`) Actor Extract structured video metadata from YouTube channels with the YouTube Channel Video Scraper. Collect titles, descriptions, views, likes, comments, dates, thumbnails, tags, hashtags, and optional video/audio formats from channel URLs, handles, IDs, or keywords. - **URL**: https://apify.com/alpha-scraper/youtube-channel-video-scraper.md - **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community) - **Categories:** Videos, Social media, Real estate - **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ### YouTube Channel Video Scraper The **YouTube Channel Video Scraper** extracts structured video metadata from YouTube channels and stores each discovered video as a separate result. It is designed for users who need channel video data for research, content analysis, dataset creation, monitoring, analytics, or automated workflows. You can provide one or more channel usernames or handles, channel IDs, channel URLs, or search keywords. The Actor combines the supplied inputs, removes duplicate channel targets, and processes up to the configured number of videos from each identified channel. For each video, the scraper can return core metadata such as the channel name, video ID, title, description, video URL, publication information, duration, view count, like count, comment count, thumbnail URL, available subtitle languages, tags, hashtags, categories, and live-status information. Optional settings can additionally return video formats, audio formats, and all available thumbnails. ### What Is the YouTube Channel Video Scraper? The **YouTube Channel Video Scraper** is a channel-focused data extraction Actor for collecting video information from identified YouTube channels. Instead of manually opening individual channel pages and recording video details, users provide channel-oriented inputs and receive structured records in the Actor dataset. This makes the collected information easier to inspect, analyze, and reuse in downstream workflows. The Actor accepts several input paths: - **Keywords** for channel discovery - **Usernames or handles** such as `MrBeast` or `@MrBeast` - **Channel IDs** beginning with `UC` - **Start URLs** containing YouTube channel links or supported channel URL forms Multiple values can be supplied within these input types. The Actor combines the resulting channel targets and avoids processing the same normalized channel more than once. ### Key Features | Feature | Description | User Benefit | | -------------------------- | ----------------------------------------------------------------------------------------------------- | -------------------------------------------- | | Multiple channel inputs | Accepts keywords, usernames/handles, channel IDs, and start URLs | Flexible channel data collection | | Duplicate channel handling | Normalized channel targets are compared before processing | Reduces duplicate channel processing | | Configurable video limit | Set the maximum number of videos processed per channel | Control dataset size | | Detailed video metadata | Collects titles, descriptions, dates, counts, URLs, duration, and more | Useful for research and analysis | | Engagement metadata | Includes tags, hashtags, categories, age-related fields, and audience-related metadata when available | Supports content analysis | | Optional video formats | Can include detailed video format records | Useful for technical video metadata research | | Optional audio formats | Can include available audio-only format information | Adds media-format detail when needed | | Optional thumbnails | Can include all available thumbnail variants | Useful for thumbnail and media analysis | | Structured dataset output | Each processed video is pushed as an individual result | Easy to inspect and analyze | ### What Data Can You Extract? Each video result contains a structured set of fields covering content, publication, engagement, media, and technical metadata. #### Video and Content Data The main video record includes: - `channel_name` - `video_id` - `video_url` - `title` - `description` - `description_links` - `playback_url` - `published_at` - `upload_date` The description is preserved as returned by the source, while `description_links` contains HTTP or HTTPS links detected within that description. #### Duration and Status The Actor also returns: - `duration_seconds` - `duration_string` - `video_type` - `is_live` - `was_live` This provides both numeric and human-readable duration information alongside live-stream status indicators. #### Engagement and Discovery Metadata The `engagement` object may contain: - `tags` - `hashtags` - `categories` - `age_limit` - `is_made_for_kids` Hashtags are extracted from the video description. The other values are populated from available video metadata. #### Counts and Media The result includes formatted values for: - `view_count` - `like_count` - `total_comments` - `thumbnail_url` - `available_languages` The count fields are formatted using compact values such as `1.2k`, `4.5m`, or `1.1b` where applicable. #### Optional Format and Thumbnail Data When enabled in the input configuration, additional fields can be returned. `video_formats` may contain format ID, extension, resolution, frame rate, file size, video codec, audio codec, and a video URL. `audio_formats` may contain format ID, extension, bitrate, file size, audio codec, and an audio URL. `thumbnails` may contain multiple thumbnail URLs together with their width and height. ### Why Use This Actor? Manually collecting video metadata from multiple channels can become repetitive, especially when the same information is needed across many channels. This **YouTube Channel Video Scraper** turns channel-oriented inputs into a structured video dataset that can support: - Automated content research - Channel and video metadata collection - Competitive content analysis - Market and audience research - Video dataset creation - Content discovery workflows - Metadata comparison - Media-format research - Reporting and analytics workflows The ability to combine several input types is particularly useful when your source list contains a mixture of handles, channel IDs, URLs, and search terms. ### Benefits for Data Collection and Research The Actor is useful when the objective is to collect consistently structured video records rather than manually copying individual details. Because each video is written as a separate dataset item, users can work with individual records while preserving related metadata such as the title, description, publication date, engagement counts, and content classification fields. Optional format and thumbnail extraction also allows the same Actor to support both general metadata collection and more detailed media-data research, depending on the configuration. ### How to Use the YouTube Channel Video Scraper The workflow is straightforward: 1. Provide one or more supported channel inputs. 2. Set the maximum number of videos to process from each channel. 3. Enable video formats, audio formats, or thumbnails when those fields are required. 4. Start the Actor. 5. Review the resulting structured video dataset. You do not need to provide every input type. Use the input method that best matches your channel list. For larger collections, start with a small `maxposts` value and verify the returned dataset before expanding the run. ### Input Fields | Field | Type | Required | Default | Description | | ------------------- | ---------------- | -------- | -------------------------- | --------------------------------------------------------------------------------------------------------------- | | `keywords` | Array of strings | No | — | Search keywords used for YouTube channel discovery. Examples include `cooking` or `tech reviews`. | | `usernames` | Array of strings | No | — | YouTube usernames or handles, with or without `@`. | | `channelIds` | Array of strings | No | — | YouTube channel IDs, normally beginning with `UC`. | | `startUrls` | Array of objects | No | — | One or more YouTube channel URLs or supported channel/share links. Each object contains a required `url` field. | | `maxposts` | Integer | No | `5` in actor configuration | Maximum number of videos processed per channel. | | `get_video_formats` | Boolean | No | `false` | Adds detailed video format information to each result. | | `get_audio_formats` | Boolean | No | `false` | Adds detailed audio-only format information to each result. | | `get_thumbnails` | Boolean | No | `false` | Adds a list of available thumbnails with dimensions. | The Actor combines populated input collections and attempts to normalize channel targets before processing them. Duplicate normalized channel targets are skipped. ### Input Example ```json { "keywords": [ "MrBeast", "technology reviews" ], "usernames": [ "@loganpaulvlogs" ], "channelIds": [ "UC-lHJZR3Gqxm24_Vd_AJ5Yw" ], "startUrls": [ { "url": "https://www.youtube.com/@PenMovies/" }, { "url": "https://www.youtube.com/@PlayDMF/" } ], "maxposts": 5, "get_video_formats": false, "get_audio_formats": false, "get_thumbnails": false } ``` ### Output The Actor writes one structured result for each processed video. The core output is intentionally centered around video metadata, publication details, engagement information, and source-related metadata. ### Output Fields | Field | Description | | --------------------- | ------------------------------------------------------------------------------------------------ | | `channel_name` | Channel name associated with the video. | | `video_id` | YouTube video identifier. | | `video_url` | Video webpage URL. | | `title` | Video title. | | `description` | Video description. | | `description_links` | HTTP or HTTPS links detected in the description. | | `playback_url` | Video URL used as the playback reference. | | `published_at` | Publication timestamp derived from the upload date when available. | | `upload_date` | Upload date in `YYYYMMDD` form when available. | | `duration_seconds` | Video duration in seconds. | | `duration_string` | Human-readable duration. | | `video_type` | Video media extension/type value. | | `is_live` | Indicates whether the entry is identified as live. | | `was_live` | Indicates whether the video was previously live. | | `view_count` | Formatted view count. | | `like_count` | Formatted like count. | | `total_comments` | Formatted comment count. | | `thumbnail_url` | Primary available thumbnail URL. | | `available_languages` | Available subtitle language keys when present. | | `engagement` | Object containing tags, hashtags, categories, age limit, and made-for-kids metadata. | | `technical` | Technical source metadata including webpage URL, original URL, extractor, and extractor version. | | `video_formats` | Optional detailed video format list when enabled. | | `audio_formats` | Optional detailed audio-only format list when enabled. | | `thumbnails` | Optional list of thumbnail variants with URLs and dimensions when enabled. | ### Output Example ```json { "channel_name": "Example Channel", "video_id": "dQw4w9WgXcQ", "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "title": "Example Video Title", "description": "Example video description with https://example.com", "description_links": [ "https://example.com" ], "playback_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "published_at": "2026-01-15T00:00:00", "upload_date": "20260115", "duration_seconds": 600, "duration_string": "00:10:00", "video_type": "mp4", "is_live": false, "was_live": false, "view_count": "1.2m", "like_count": "45.6k", "total_comments": "3.4k", "thumbnail_url": "https://example.com/thumbnail.jpg", "available_languages": [ "en" ], "engagement": { "tags": [ "technology" ], "hashtags": [ "Tech" ], "categories": [ "Science & Technology" ], "age_limit": 0, "is_made_for_kids": false }, "technical": { "webpage_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "original_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "extractor": "youtube", "extractor_version": "example" } } ``` The example uses placeholder values to illustrate the structure. Actual metadata depends on the video being processed. ### Use Cases The collected video dataset can support several practical workflows. **Content research:** Analyze titles, descriptions, tags, hashtags, categories, and publication dates across selected channels. **Competitive research:** Compare video publishing patterns and engagement metadata across channel datasets. **Dataset creation:** Build structured collections of channel videos for analytics, research, or internal data projects. **Media research:** Use optional format and thumbnail information when studying available video or audio representations. **Channel monitoring:** Re-run the Actor periodically to collect a configurable number of recent channel videos for comparison over time. **Business intelligence:** Combine video metadata and engagement indicators with other research datasets for broader analysis. **Academic research:** Use structured channel video records as source material for studies involving online video content and publishing activity. ### Advantages The main strengths of this Actor are its flexible input model and configurable output depth. A user can start with a simple handle or URL, while more advanced workflows can provide channel IDs, multiple channels, or search-oriented keywords. The output also combines core video metadata with nested engagement and technical information. Optional media fields can be enabled only when they are relevant to the task, helping users choose between a simpler metadata dataset and a more detailed result. ### Limitations Several practical limitations should be considered: - Keyword-based discovery depends on finding a channel from the resulting YouTube search information. A keyword does not represent an exact channel identifier. - The number of processed videos is controlled per channel through `maxposts`. - Some metadata fields may be unavailable for particular videos, so values can be empty, missing, or represented by defaults. - Video, audio, and thumbnail details are optional and are only added when their corresponding switches are enabled. - A failed or unavailable channel may produce no usable video records for that target. - The Actor processes identified channel targets; it is not documented as a general-purpose search-results scraper for arbitrary YouTube search pages. ### Pros and Cons | Pros | Cons | | -------------------------------------------------- | --------------------------------------------------------------------- | | Supports multiple channel input methods | Keyword discovery may not identify the intended channel in every case | | Combines multiple inputs in one run | Maximum videos are controlled per channel | | Removes duplicate normalized channel targets | Some source metadata may be unavailable | | Provides structured video records | Optional detailed fields increase output size | | Supports optional video, audio, and thumbnail data | Results depend on available source metadata | ### Comparison With Alternative Approaches | Capability | This Actor | Manual / Typical Alternative | | ----------------------------------- | -------------------------------- | --------------------------------------------- | | Multiple channel inputs | Supported | Often handled one source at a time | | Automated video metadata collection | Supported | Usually requires repeated manual collection | | Structured dataset records | Supported | Often requires manual formatting | | Configurable videos per channel | Supported through `maxposts` | Usually controlled manually | | Optional format metadata | Supported when enabled | Requires additional manual inspection | | Optional thumbnail collection | Supported when enabled | Often requires collecting variants separately | | Duplicate channel handling | Supported for normalized targets | Usually requires manual deduplication | This comparison describes workflow differences rather than a universal performance ranking. ### Competitive Advantages The Actor provides a practical combination of channel discovery, channel identification, configurable video limits, and structured metadata output. Its flexible input model is useful when a project does not have one standardized source list. Handles can be mixed with channel IDs and URLs, while keyword-based discovery provides another way to identify channels. The optional fields are also useful for tailoring the dataset. A metadata-focused run can leave media-detail options disabled, while a more technical research workflow can request format or thumbnail information. ### Best Practices - Start with a small number of channels and a low `maxposts` value to confirm that your inputs resolve to the expected targets. - Use direct channel URLs or channel IDs when you already know the exact channels you need. - Use usernames with or without `@`; the Actor normalizes the handle for processing. - Enable `get_video_formats`, `get_audio_formats`, or `get_thumbnails` only when those fields are necessary for your analysis. - Review the resulting dataset before running a larger collection. - Treat source-dependent fields such as counts, tags, subtitles, or categories as potentially variable. - Validate important records before using them in critical research or reporting. ### Troubleshooting **Invalid or unexpected input:** Check that channel handles, channel IDs, and URLs use the documented forms. For `startUrls`, every array item must contain a `url` field. **Empty results:** Verify that the supplied target identifies a valid YouTube channel and try a direct channel URL or channel ID when available. **Partial results:** Some videos may not provide complete metadata, and individual channel targets may fail to return usable information. **Missing optional fields:** Confirm that the corresponding setting is enabled. `video_formats`, `audio_formats`, and `thumbnails` are only included when requested. **Unexpected keyword results:** Keywords are used for channel discovery, so the discovered channel should be reviewed before treating the resulting dataset as a specific-channel collection. **Temporary failures:** Recheck the input and run the Actor again. For important datasets, review the returned records rather than assuming every requested channel produced the same number of items. ### Frequently Asked Questions **What does the YouTube Channel Video Scraper do?** It collects structured metadata for videos from identified YouTube channels and writes each video as a separate dataset result. **What inputs does the YouTube Channel Video Scraper support?** It supports arrays of keywords, usernames or handles, channel IDs, and start URLs. **Can I provide multiple channels in one run?** Yes. Multiple values can be supplied across the supported input fields, and normalized duplicate channel targets are skipped. **What is `maxposts`?** `maxposts` controls the maximum number of videos processed from each channel. The actor configuration specifies a default value of `5`. **Can I use a YouTube channel URL directly?** Yes. `startUrls` accepts YouTube channel URLs and supported channel URL forms. The Actor normalizes channel targets before processing. **Can keywords be used instead of channel IDs?** Yes. Keywords can be supplied for channel discovery. Because this is discovery-based, users should verify that the identified channel is the intended target. **Does the scraper return video descriptions and links?** Yes. The output includes the full description and a separate list of HTTP or HTTPS links detected in that description. **Can I collect video and audio format information?** Yes. Enable `get_video_formats` and/or `get_audio_formats` to add those corresponding output fields. **Can I collect all available thumbnails?** Yes. Set `get_thumbnails` to `true` to add the thumbnail list with URL, width, and height information. **What happens when metadata is unavailable?** Some fields can be empty, unavailable, or represented by defaults depending on the source data returned for a particular video. **Is the YouTube Channel Video Scraper suitable for automation?** Yes. The Actor produces structured per-video records that can be reused in automated research, dataset-building, monitoring, and analysis workflows. ### NLP Keywords - YouTube channel video data - YouTube video metadata - YouTube channel scraper - channel video extraction - YouTube video information - channel video dataset - YouTube content metadata - video title extraction - YouTube description data - video engagement metadata - YouTube view count - YouTube like count - YouTube comment count - YouTube thumbnail data - YouTube video formats - YouTube audio formats - YouTube channel IDs - YouTube channel handles - YouTube video research - structured YouTube data ### Related Keywords - YouTube channel data scraper - YouTube video scraper - scrape YouTube channel videos - YouTube channel metadata extractor - YouTube video metadata scraper - extract YouTube video details - YouTube channel video extractor - YouTube channel content scraper - YouTube video dataset builder - YouTube video information extractor - channel video data collection - YouTube content research scraper - YouTube video analytics data - YouTube thumbnail extractor - YouTube video format extractor - YouTube audio format scraper - YouTube channel URL scraper - YouTube handle scraper - YouTube channel ID scraper - automated YouTube video data extraction ### Final Overview The **YouTube Channel Video Scraper** provides a flexible way to turn channel-oriented YouTube inputs into structured video data. It supports keywords, handles, channel IDs, and channel URLs, combines multiple targets, removes duplicate normalized channels, and limits collection per channel with `maxposts`. Its standard output covers video identity, titles, descriptions, publication data, durations, engagement counts, thumbnails, subtitle-language availability, hashtags, categories, and other metadata. Optional configuration adds video formats, audio formats, and thumbnail variants when those details are required. For content research, competitive analysis, dataset creation, channel monitoring, media research, and automated workflows, the Actor provides a clear input-to-output process: provide channel targets, configure the collection depth, start the Actor, and work with the resulting structured video dataset. **Contact me:** # Actor input Schema ## `keywords` (type: `array`): List of keywords. If provided, the actor can build YouTube search or discovery URLs. Example: "cooking" or "tech reviews". ## `usernames` (type: `array`): List of channel handles or usernames (with or without @). Examples: "MrBeast", "@MrBeast". The actor will convert these to: https://www.youtube.com/@USERNAME/posts ## `channelIds` (type: `array`): List of channel IDs (starting with UC...). The actor will convert to https://www.youtube.com/channel/CHANNEL\_ID/posts ## `startUrls` (type: `array`): List of one or more YouTube channel URLs or share links to scrape. These will be added to the list of channels found via other inputs. ## `maxposts` (type: `integer`): Maximum number of posts to extract from each channel (integer). ## `get_video_formats` (type: `boolean`): If enabled, includes detailed video format information in the output. ## `get_audio_formats` (type: `boolean`): If enabled, includes detailed audio format information in the output. ## `get_thumbnails` (type: `boolean`): If enabled, includes a list of all available thumbnails in the output. ## Actor input object example ```json { "keywords": [ "MrBeast" ], "usernames": [ "@loganpaulvlogs" ], "channelIds": [ "UC-lHJZR3Gqxm24_Vd_AJ5Yw" ], "startUrls": [ { "url": "https://www.youtube.com/@PenMovies/" }, { "url": "https://www.youtube.com/@PlayDMF/" } ], "maxposts": 5, "get_video_formats": false, "get_audio_formats": false, "get_thumbnails": false } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "keywords": [ "MrBeast" ], "usernames": [ "@loganpaulvlogs" ], "channelIds": [ "UC-lHJZR3Gqxm24_Vd_AJ5Yw" ], "startUrls": [ { "url": "https://www.youtube.com/@PenMovies/" }, { "url": "https://www.youtube.com/@PlayDMF/" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("alpha-scraper/youtube-channel-video-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "keywords": ["MrBeast"], "usernames": ["@loganpaulvlogs"], "channelIds": ["UC-lHJZR3Gqxm24_Vd_AJ5Yw"], "startUrls": [ { "url": "https://www.youtube.com/@PenMovies/" }, { "url": "https://www.youtube.com/@PlayDMF/" }, ], } # Run the Actor and wait for it to finish run = client.actor("alpha-scraper/youtube-channel-video-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "keywords": [ "MrBeast" ], "usernames": [ "@loganpaulvlogs" ], "channelIds": [ "UC-lHJZR3Gqxm24_Vd_AJ5Yw" ], "startUrls": [ { "url": "https://www.youtube.com/@PenMovies/" }, { "url": "https://www.youtube.com/@PlayDMF/" } ] }' | apify call alpha-scraper/youtube-channel-video-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/youtube-channel-video-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/EdF33psXUFplYiBMl/builds/aEcQZbKozlvoWfQmP/openapi.json