# Youtube Video Details Scraper (`alpha-scraper/youtube-video-details-scraper`) Actor youtube video details scraper extracts detailed YouTube video metadata, including titles, descriptions, tags, hashtags, channel details, views, likes, comments, thumbnails, duration, and publication dates from multiple video URLs into structured Apify Dataset records. - **URL**: https://apify.com/alpha-scraper/youtube-video-details-scraper.md - **Developed by:** [Alpha Scraper](https://apify.com/alpha-scraper) (community) - **Categories:** Videos, Social media, Other - **Stats:** 14 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: 5.00 out of 5 stars ## 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 Video Details Scraper **YouTube Video Details Scraper** is an Apify Actor for extracting structured metadata from YouTube video URLs. It accepts one or more video URL inputs, retrieves available video and channel information, and stores each successful result as a structured dataset item. The Actor is designed for users who need **YouTube video metadata extraction** for research, content analysis, channel research, dataset creation, analytics, and automation workflows. Each result can include the video ID, title, description, hashtags, tags, uploader information, channel information, publication date, duration, engagement counts, thumbnail URL, playback URL, and additional video status metadata. The main input is **Start URLs**, which can contain multiple URL entries. The Actor also supports proxy configuration through the Apify input interface, with the provided configuration prefilled for the **RESIDENTIAL** proxy group. The processing flow is straightforward: provide supported YouTube video URLs, configure the available proxy setting when needed, start the Actor, and review the resulting dataset. ### What Is the YouTube Video Details Scraper? A YouTube video details scraper extracts publicly available metadata associated with individual YouTube videos and organizes that information into structured records. This Actor focuses on detailed video-level information rather than downloading video files. It extracts metadata such as: - Video title and description - Video and channel identifiers - YouTube URLs - Hashtags and description links - Video tags and categories - Uploader and channel information - Channel description and tags when available - Publication date - Duration and media extension information - View, like, and comment counts - Thumbnail URL - Playback URL when available - Availability and live-status information - Average rating when available - Embedding and webpage metadata The output is written to the Actor dataset, with one dataset item generated for each successfully processed video. ### 🔍 Key Features | Feature | Description | User Benefit | | --------------------------- | ---------------------------------------------------------------------------- | ---------------------------------------------------------- | | Multiple Start URLs | Process one or more supplied YouTube URLs in a single run. | Convenient for batch video metadata collection. | | Video metadata extraction | Collects titles, descriptions, IDs, tags, dates, duration, and other fields. | Creates structured video research data. | | Description link extraction | Detects URLs contained in the video description. | Helps identify external resources associated with a video. | | Hashtag extraction | Extracts hashtags from the description text. | Useful for topic and content analysis. | | Channel metadata | Retrieves channel description and tags when available. | Adds channel context to video-level records. | | Engagement metrics | Returns formatted view, like, and comment counts. | Makes performance information easier to review. | | Thumbnail URL | Provides a generated YouTube thumbnail URL for the video. | Useful for previews and visual datasets. | | Playback URL | Returns a playback URL when a suitable format is available. | Provides an additional media-related reference. | | Structured dataset output | Each successful video is pushed as a dataset record. | Makes collected data easier to analyze and process. | ### 📊 What Data Can You Extract? The YouTube Video Details Scraper returns a broad set of metadata in a single record. **Video information** includes the original URL, video ID, short URL, title, description, video duration, media extension, publication date, thumbnail URL, and playback URL. **Description-related data** includes URLs detected in the description and extracted hashtags. Video tags are returned separately when available. **Uploader and channel data** includes the uploader name, uploader ID, uploader URL, verification status, channel ID, channel name, channel URL, channel description, and channel tags. **Engagement information** includes view count, like count, and total comments. These counts are formatted into compact representations such as `1.2M` or `850K`. The nested `other` object can contain categories, availability status, live status, whether the video was previously live, embed-playability information, average rating, and the webpage URL. ### ✅ Why Use the YouTube Video Details Scraper? Manual collection of YouTube metadata can become repetitive when many videos need to be reviewed. This Actor turns supported video URLs into structured records that are easier to inspect, organize, and reuse. It is particularly useful when your workflow requires consistent metadata fields across multiple videos. Instead of copying information from individual video pages, you can provide a batch of supported URLs and receive dataset records containing the available metadata. The Actor can support workflows involving **YouTube video research**, content discovery, competitor analysis, video cataloging, performance review, and structured dataset creation. ### 🚀 Benefits The main practical benefits include: - **Automation:** Reduce repetitive manual metadata collection. - **Structured results:** Receive consistent fields in dataset records. - **Batch input:** Supply multiple supported video URLs in one run. - **Research support:** Collect useful metadata for content and channel research. - **Dataset creation:** Build organized records for analysis and downstream processing. - **Content analysis:** Combine titles, descriptions, tags, hashtags, categories, and engagement metrics. - **Channel context:** Add available channel information alongside video-level data. - **Workflow flexibility:** Use the resulting dataset for further processing or analysis. ### ⚙️ How to Use the YouTube Video Details Scraper Using the Actor requires only a few user-facing steps: 1. Add one or more supported YouTube video URLs to **Start URLs**. 2. Configure the available proxy settings when appropriate. 3. Start the Actor. 4. Wait for the processing run to finish. 5. Open the dataset and review the returned records. For initial testing, start with a small number of URLs. This makes it easier to confirm that your inputs are valid and that the returned data matches your workflow before processing a larger batch. ### 📥 Input The Actor accepts an object containing the required `startUrls` field and an optional `proxyConfiguration` object. #### Input Fields | Field | Type | Required | Default / Prefill | Description | | -------------------- | ------ | -------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- | | `startUrls` | Array | Yes | Two example YouTube video URLs are prefilled in the UI | One or more YouTube URL entries. The Actor reads either a URL string or an object containing a `url` property. | | `proxyConfiguration` | Object | No | Apify Proxy with `RESIDENTIAL` group prefilled | Proxy configuration exposed through the Apify proxy editor. | The URL processing logic is designed for supported **individual YouTube video URLs**. A URL must contain a recognizable YouTube video ID before a video record can be produced. Although the Actor input description mentions video or playlist URLs, the current processing logic extracts an 11-character video ID from supported video URL patterns. A playlist-only URL without a video ID should therefore not be relied upon as a supported standalone input. #### Input Example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g" }, { "url": "https://www.youtube.com/watch?v=zxYjTTXc-J8" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` ### 📤 Output For every successfully processed video, the Actor pushes one structured item to the dataset. The result contains top-level video, uploader, channel, engagement, and media-related fields, plus a nested `other` object containing additional metadata. #### Output Fields | Field | Description | | ------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | `url` | Input URL processed by the Actor. | | `video_id` | Extracted YouTube video ID. | | `short_url` | Short YouTube URL generated from the video ID. | | `title` | Video title. | | `description` | Video description text. | | `description_links` | URLs detected in the description. | | `hashtags` | Hashtags extracted from the description. | | `tags` | Available YouTube video tags. | | `uploader` | Uploader name. | | `uploader_id` | Uploader identifier. | | `uploader_url` | Uploader or channel URL. | | `uploader_verified` | Indicates whether the available channel metadata reports verification. | | `channel_id` | YouTube channel ID. | | `channel_name` | Channel name. | | `channel_url` | Channel URL. | | `channel_about` | Channel description when available. | | `channel_tags` | Channel tags when available. | | `publish_date` | Publication date formatted as `DD:MM:YYYY`. | | `video_duration` | Video duration value returned by the source metadata. | | `video_type` | Media extension reported for the video. | | `view_count` | Formatted view count. | | `like_count` | Formatted like count. | | `total_comments` | Formatted comment count. | | `thumbnail_url` | Generated YouTube thumbnail URL. | | `playback_url` | Playback URL when a suitable format is available. | | `other` | Additional metadata including categories, availability, live status, embedding information, average rating, and webpage URL. | #### Output Example ```json { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g", "video_id": "TJPFYs_88-g", "short_url": "https://youtu.be/TJPFYs_88-g", "title": "Example YouTube Video", "description": "Example video description with https://example.com/resource", "description_links": [ "https://example.com/resource" ], "hashtags": [ "#Example", "#YouTube" ], "tags": [ "example", "youtube" ], "uploader": "Example Channel", "uploader_id": "example-uploader-id", "uploader_url": "https://www.youtube.com/channel/example-channel-id", "uploader_verified": false, "channel_id": "example-channel-id", "channel_name": "Example Channel", "channel_url": "https://www.youtube.com/channel/example-channel-id", "channel_about": "Example channel description.", "channel_tags": [ "example", "video" ], "publish_date": "15:09:2026", "video_duration": 245, "video_type": "mp4", "view_count": "1.2M", "like_count": "25K", "total_comments": "850", "thumbnail_url": "https://i.ytimg.com/vi/TJPFYs_88-g/maxresdefault.jpg", "playback_url": "https://example.com/playback-url", "other": { "categories": [ "People & Blogs" ], "availability": "public", "live_status": "not_live", "was_live": false, "playable_in_embed": true, "average_rating": null, "webpage_url": "https://www.youtube.com/watch?v=TJPFYs_88-g" } } ``` Values in this example are illustrative. Actual fields and values depend on the metadata available for the processed video. ### 🔎 Use Cases The Actor is suitable for several practical **YouTube data extraction** workflows. **Content research:** Collect titles, descriptions, tags, hashtags, categories, and publication details for groups of videos. **Competitive research:** Build structured records for analyzing videos published by channels or content creators. **Video cataloging:** Create datasets containing video identifiers, URLs, titles, duration, thumbnails, and other metadata. **Performance analysis:** Use formatted views, likes, and comments together with publication information for comparative analysis. **Lead and business research:** Review public channel and uploader metadata as part of broader research workflows where YouTube is a relevant data source. **Dataset creation:** Build reusable collections of YouTube video metadata for internal analysis, reporting, or downstream processing. **Automation:** Integrate recurring video metadata collection into larger Apify-based workflows. ### 💡 Competitive Advantages The Actor provides a practical combination of video-level and channel-level metadata in a single dataset item. Its structured output reduces the need to manually normalize fields such as video IDs, URLs, descriptions, hashtags, engagement counts, and channel information. Another useful characteristic is that the Actor accepts multiple Start URLs, allowing users to process a batch of individual video URLs within the same run. The output also combines directly extracted video information with additional user-friendly fields such as description links, hashtags, formatted engagement counts, a short URL, and a nested `other` metadata object. ### ⚖️ Pros and Cons | Pros | Cons | | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | | Supports multiple video URL inputs. | Playlist-only URLs are not reliably supported by the current video-ID extraction logic. | | Returns extensive video and channel metadata. | Some fields may be empty or unavailable for particular videos. | | Produces structured dataset records. | Playback URL availability can vary. | | Extracts description links and hashtags. | Publication time is represented as `00:00:00` in the processing logic and is not a source upload timestamp. | | Includes engagement-related fields. | Unavailable, private, deleted, or inaccessible videos may produce no dataset item. | ### 🔧 Limitations The Actor only produces a dataset record when it can successfully extract a supported video ID and retrieve usable video metadata. A standalone playlist URL without an identifiable video ID should not be treated as a guaranteed supported input, even though the Actor's UI description refers to video or playlist URLs. Some YouTube metadata can vary by video. Channel descriptions, channel tags, average ratings, playback URLs, tags, counts, and status information may be unavailable or empty. The publication date is formatted as `DD:MM:YYYY`. The helper used by the Actor does not derive the actual upload clock time, so the associated formatted time is `00:00:00`. Private, deleted, unavailable, or inaccessible videos may fail to produce a dataset result. These cases are logged rather than returned as successful records. The thumbnail field uses a YouTube `maxresdefault.jpg` URL generated from the video ID. Availability of that particular thumbnail rendition can depend on the video. ### ✅ Best Practices For reliable use of the YouTube Video Details Scraper: - Begin with one or two known-valid YouTube video URLs to verify the workflow. - Use individual video URLs containing a valid YouTube video ID. - Review dataset results before running a large batch. - Treat optional metadata as potentially unavailable. - Validate important engagement or channel information before using it in high-value analysis. - Use the Apify proxy configuration when it is appropriate for your run and configured through the Actor input. ### 🛠️ Troubleshooting **Invalid Input** Check that each Start URL is a valid YouTube video URL and contains a recognizable video ID. Playlist-only URLs may not work unless a supported video ID is present. **Empty Results** An input may fail when the video is unavailable, private, deleted, inaccessible, or when usable metadata cannot be retrieved. Test with another public video URL to isolate the issue. **Partial Metadata** Some fields depend on what metadata is available for the specific video or channel. An empty field does not necessarily indicate a problem with the entire result. **Missing Playback URL** The Actor only returns a playback URL when a suitable format is available in the extracted metadata. Do not assume this field will always be populated. **Missing Channel Information** Channel description or channel tags may be unavailable even when the video itself is successfully processed. **Temporary Failure** Review the input URL and proxy configuration, then retry with a known-valid video. Testing a smaller set of URLs can also help identify a problematic input. ### ❓ Frequently Asked Questions **What does the YouTube Video Details Scraper do?** It extracts structured metadata from supported YouTube video URLs and stores successful results in an Apify dataset. **What data does the YouTube Video Details Scraper extract?** It can return video details, descriptions, hashtags, tags, uploader information, channel information, publication date, duration, engagement counts, thumbnail and playback references, and additional metadata. **What input does the Actor require?** The required input is `startUrls`, an array containing one or more URL entries. **Can I process multiple YouTube videos in one run?** Yes. The Actor accepts multiple Start URL entries and processes them within the same Actor run. **Can I submit a playlist URL?** The current processing logic is centered on extracting an individual video ID. A playlist-only URL without a video ID should therefore not be relied upon as a supported standalone input. **What output format does the Actor use?** Successful results are pushed as structured records to the Actor dataset. **Does the Actor extract YouTube descriptions and hashtags?** Yes. It returns the full available description, extracts URLs found in that description, and extracts hashtags separately. **Are channel details included?** Yes. The result can include channel ID, name, URL, description, tags, and uploader information when those values are available. **Are view, like, and comment counts returned?** Yes. The Actor returns these values using compact formatted representations such as `K`, `M`, and `B`. **What happens when a video is private or unavailable?** The Actor logs the failure and does not push a successful dataset item for that video. ### 🔐 Privacy and User-Facing Data The README documents only the information users can expect in the Actor's input and output. It does not expose internal request logic, source-code implementation details, private infrastructure, credentials, cookies, authentication secrets, or other internal mechanisms. Users should treat the returned YouTube metadata according to their own legal, contractual, privacy, and data-use requirements. ### NLP Keywords - YouTube video metadata - YouTube video data extraction - YouTube video scraper - YouTube metadata scraper - YouTube video information - YouTube video details - YouTube channel metadata - YouTube video ID extraction - YouTube description extraction - YouTube hashtags - YouTube video tags - YouTube engagement metrics - YouTube view count - YouTube like count - YouTube comment count - YouTube publication date - YouTube thumbnail URL - YouTube video duration - YouTube uploader data - structured YouTube data ### Related Keywords - YouTube video details extractor - YouTube video metadata extractor - extract YouTube video information - scrape YouTube video metadata - YouTube video data scraper - YouTube video research scraper - YouTube video details API alternative - YouTube video information extractor - YouTube content metadata extraction - YouTube channel and video data - YouTube video dataset generator - YouTube video analytics data - YouTube public video metadata - bulk YouTube video metadata - YouTube description scraper - YouTube video tags scraper - YouTube video engagement data - YouTube thumbnail metadata - automated YouTube data collection - structured YouTube video dataset ### Final Overview The **YouTube Video Details Scraper** provides a structured way to collect detailed metadata from supported YouTube video URLs. By combining video information, description data, hashtags, tags, uploader details, channel context, publication information, engagement metrics, thumbnail references, and additional status metadata, it can serve as a practical foundation for research and automated YouTube data workflows. Its input structure is simple: provide supported video URLs through `startUrls`, configure the available proxy options when needed, and run the Actor. Successful results are stored as structured dataset records that can be reviewed and used in downstream analysis. For the most predictable results, use valid individual YouTube video URLs and begin with a small test run before processing a larger collection. **Contact me:** # Actor input Schema ## `startUrls` (type: `array`): List of one or more YouTube video or playlist URLs ## `proxyConfiguration` (type: `object`): Apify proxy / custom proxy configuration used by the actor. ## Actor input object example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g" }, { "url": "https://www.youtube.com/watch?v=zxYjTTXc-J8" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # 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 = { "startUrls": [ { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g" }, { "url": "https://www.youtube.com/watch?v=zxYjTTXc-J8" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("alpha-scraper/youtube-video-details-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 = { "startUrls": [ { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g" }, { "url": "https://www.youtube.com/watch?v=zxYjTTXc-J8" }, ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("alpha-scraper/youtube-video-details-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 '{ "startUrls": [ { "url": "https://www.youtube.com/watch?v=TJPFYs_88-g" }, { "url": "https://www.youtube.com/watch?v=zxYjTTXc-J8" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call alpha-scraper/youtube-video-details-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,alpha-scraper/youtube-video-details-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/On4VfiWjGnT79clm1/builds/SXVvYmb1U1Ih7rcVH/openapi.json