# Youtube Video Details Scraper (`solid-scraper/youtube-video-details-scraper`) Actor 🎥 YouTube Video Details Scraper extracts titles, views, tags & more in seconds. ⚡ Save time, boost SEO research, and grow smarter content strategies with organized results. Perfect for creators, marketers & data teams! 🚀 - **URL**: https://apify.com/solid-scraper/youtube-video-details-scraper.md - **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community) - **Categories:** Automation, SEO tools, Videos - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.99 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ### YouTube Video Details Scraper 🔍 **YouTube Video Details Scraper** automatically pulls YouTube video metadata (views, likes, comments, etc.) and full transcripts with timestamps. If you’re looking for a **YouTube video details scraper** or a **YouTube metadata scraper** to speed up research, it’s built for one job: turning video URLs into structured, export-ready data—without manual copy-pasting. Whether you’re a marketer, data analyst, researcher, or YouTube-focused operator, this actor helps you extract consistent YouTube video info extraction tool outputs at scale—saving you hours of manual work. --- ### Why choose YouTube Video Details Scraper? | Feature | Benefit | |---|---| | ✅ **All-in-one video metadata + transcript** | Extract YouTube video details scraper results including stats plus full transcript segments with timestamps | | ✅ **Structured output for easy analysis** | Produces a consistent dataset with fields like `views`, `likes`, `comment_count`, and `engagement_rate` | | ✅ **Built-in reliability with fallbacks** | Includes retries for metadata requests and multiple transcript language fallbacks | | ✅ **Residential proxy support** | Built to work reliably on larger batches with proxy support for more consistent scraping | | ✅ **Real-time dataset writing** | Saves each processed video immediately to reduce risk of losing progress | | ✅ **Simple automation workflow** | Feed a list of video URLs and get results without building custom scraping scripts | --- ### Key features - 📊 **YouTube video statistics extraction**: Captures `views`, `likes`, `comment_count`, and computes `engagement_rate` - 📝 **Full transcript with timestamps**: Returns transcript segments with `start`, `dur`, and `text` - 🔗 **URL input for video pages**: Accepts `startUrls` as a list of YouTube video URLs to process - 🛡️ **Resilience for real-world availability**: Uses retries for metadata fetching to improve success rate during transient issues - 🔄 **Transcript language fallbacks**: Tries your `language` preference, then falls back through common English options and generated transcripts - 💾 **Dataset-ready output**: Writes results into the Apify dataset titled **Video Results** - 🌐 **Metadata completeness focus**: Extracts key video fields such as `title`, `channel_name`, `published_date`, `duration_seconds`, `category`, `language`, and `live_status` - ⚙️ **Clear success signaling**: Includes a boolean `success` so you can filter successful scrapes quickly --- ### Input Provide input via an `input.json` file. Example structure: ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }, { "url": "https://www.youtube.com/watch?v=VIDEO_ID_HERE" } ] } ```` #### Input Fields | Field | Required | Description | |---|---|---| | `startUrls` | Yes | A list of YouTube video URLs to scrape. Each item can be either a plain string URL or an object with a `url` field. | *** ### Output The actor saves each processed video’s data as JSON records in the **Video Results** dataset. Example output record: ```json { "type": "video", "video_id": "dQw4w9WgXcQ", "title": "Some video title", "description": "Some short description", "channel_id": "CHANNEL_ID", "channel_name": "Channel name", "published_date": "2009-10-01", "duration_seconds": 213, "views": 1000000, "likes": 50000, "comment_count": 12000, "tags": ["music", "example"], "thumbnails": { "default": "https://example.com/thumb.jpg" }, "channel": { "id": "CHANNEL_ID", "name": "Channel name", "handle": null, "url": "https://www.youtube.com/channel/CHANNEL_ID", "subscriberCount": null, "logo": null, "badges": [] }, "transcript": [ { "start": "0.000", "dur": "3.500", "text": "First transcript segment..." } ], "category": "Music", "language": "en", "live_status": "not_live", "engagement_rate": 0.0625, "hashtags": ["example", "music"], "upload_type": "normal", "resolution": "640x360", "success": true, "inputUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ``` #### Output Fields | Field | Type | Description | |---|---|---| | `video_id` | string | null | The extracted YouTube video ID | | `title` | string | null | The video title | | `channel_name` | string | null | The channel name associated with the video | | `published_date` | string | null | Publication date in `YYYY-MM-DD` format (when available) | | `views` | number | View count (parsed into an integer value) | | `likes` | number | Like count (parsed into an integer value) | | `comment_count` | number | Comment count (parsed into an integer value) | | `duration_seconds` | number | Video duration in seconds | | `category` | string | Video category (defaults to `"Music"` when not found) | | `language` | string | Language (defaults to `"en"` in this actor) | | `live_status` | string | `"live"` or `"not_live"` | | `engagement_rate` | number | Computed engagement rate: `(likes + comment_count) / views` rounded to 4 decimals | | `inputUrl` | string | The input video URL you provided | | `success` | boolean | `true` when the actor extracted a `video_id`, otherwise `false` | Note: The actor also populates additional fields such as `transcript` and `hashtags` on each record, and pushes the full `video_metadata` object to the dataset. *** ### How to use YouTube Video Details Scraper (via Apify Console) 1. **Open Apify Console**: Log in at [console.apify.com](https://console.apify.com) and navigate to the **Actors** tab. 2. **Find the actor**: Search for **YouTube Video Details Scraper** (YouTube Video Details Scraper). 3. **Go to the INPUT panel**: Paste your input JSON into the input editor. 4. **Add your video URLs**: In `startUrls`, provide one or more YouTube video links (either as strings or as `{ "url": "..." }` objects). 5. **Choose proxy settings (optional)**: The actor attempts to create residential proxy support automatically; if proxy configuration cannot be created, it continues without a proxy. 6. **Run the actor**: Click **Run**. Watch logs to see which URLs are being processed and whether requests or transcripts fall back during failures. 7. **Review the dataset output**: After completion, open the **Video Results** dataset to view rows in the table format. 8. **Export your data**: Export the dataset to your preferred format (for example, JSON or CSV) for spreadsheets, CRM imports, or analytics workflows. No coding required—get accurate results in minutes. *** ### Advanced features & SEO optimization - 🔍 **Engineered for YouTube metadata scraping**: Optimized specifically for “YouTube video details scraper” workflows—video title, description, channel info, and engagement metrics in one pass. - 📼 **Transcript-first extraction**: Designed to return transcript segments with timestamps, making it useful for “YouTube transcript scraper and details” use cases. - 🛡️ **Retry and fallback logic**: Includes retries for metadata fetching and multiple transcript language fallbacks to improve resilience. - 🌐 **Residential proxy support**: Uses residential proxy support for more reliable scraping at scale, especially when processing larger URL batches. - 🧩 **Keyword-ready extraction**: Includes `hashtags` derived from the video description, which can help with topic tagging for “YouTube video metadata parser” pipelines. *** ### Best use cases - 📈 **Marketing teams building influencer insights**: Turn YouTube video links into a dataset of views, likes, comments, and engagement rate for campaign benchmarking. - 🎓 **Researchers analyzing audience engagement**: Compare video performance across channels using consistent YouTube metadata scraper outputs. - 🧠 **Content analysts researching themes**: Use scraped titles/descriptions plus transcript timestamps for qualitative analysis and coding. - 🛠️ **Developers creating enrichment pipelines**: Feed video URLs in `startUrls` and store structured YouTube video info extraction tool results for downstream processing. - 💼 **Agencies running competitive audits**: Quickly compile “YouTube video statistics views likes comments” snapshots for content strategy and reporting. - 📚 **Dataset builders for machine learning**: Combine video metadata and transcript segments to build training corpora and evaluation sets. - 🔎 **Playlist and channel research at scale**: Use video URLs you already have (from other tools or workflows) to populate a “YouTube playlist video details scraper” dataset. *** ### Technical specifications - **Supported Input Formats** - ✅ `startUrls` as an array of YouTube video URLs (strings or `{ "url": "..." }` objects) - **Proxy Support** - ✅ Residential proxy support (attempted automatically via actor proxy configuration) - ❌ No other proxy modes are defined by the actor input schema - **Retry Mechanism** - ✅ Retries metadata requests up to **3 attempts** with backoff behavior - **Dataset Structure** - ✅ Dataset title: **Video Results** - ✅ Output uses the dataset transformation fields including `video_id`, `title`, `views`, `likes`, `comment_count`, `duration_seconds`, `engagement_rate`, `inputUrl`, `success`, and more - **Rate Limits & Performance** - ✅ Designed for batch processing via async requests per run - ❗ Performance varies depending on availability and network conditions - **Limitations** - ❌ If a video page cannot be fetched or parsed, you’ll see `success: false` - ❌ Transcript availability can vary; the actor returns an empty transcript list when it can’t retrieve transcripts *** ### FAQ #### Do I need to log in to use YouTube Video Details Scraper? ❓ No. YouTube Video Details Scraper is designed to scrape video metadata and transcripts from publicly accessible sources without requiring authenticated access. #### What does the actor extract from each YouTube video? ✅ It extracts YouTube video metadata including `title`, `channel_name`, `published_date`, `views`, `likes`, `comment_count`, `duration_seconds`, `category`, `language`, `live_status`, and computes `engagement_rate`. It also fetches a full transcript with timestamps and returns it in the record. #### Where can I see the results after the run? ✅ The actor saves outputs to the **Video Results** dataset. You can view them in the dataset table and export the dataset for JSON/CSV use. #### Can the actor handle large lists of YouTube URLs? ✅ Yes. YouTube Video Details Scraper is built to process multiple items from `startUrls` and includes residential proxy support plus retries to improve resilience during batch runs. #### Does it always return a transcript? ❌ Not always. Transcript availability depends on what’s accessible for the video. If the transcript can’t be retrieved, the actor returns an empty `transcript` list. #### How can I tell if a specific video was scraped successfully? ✅ Each record includes a boolean `success`. In this actor, `success` is `true` when a `video_id` is successfully extracted; otherwise it’s `false`. #### Is this tool meant for YouTube metadata scraper workflows or contact enrichment? ✅ It’s meant for YouTube video metadata scraping and transcript extraction. (For example, it can support analytics and research pipelines that use YouTube metadata parser outputs.) #### Can I use it from a code workflow or only via the UI? ✅ You can run it via Apify Console for quick runs, and it’s also compatible with standard Apify automation patterns where you provide `input.json` containing `startUrls`. *** ### Support & feature requests Have questions or want improvements to YouTube Video Details Scraper (YouTube video details scraper and metadata scraping workflows)? We’d love to hear from you. - 💡 **Feature Requests**: Want enhancements like additional transcript formatting, more export-friendly fields, or new output shapes for your YouTube metadata scraper pipeline? Share your ideas. - 📧 **Contact**: Email us at Your feedback helps shape the roadmap for YouTube video metadata parser use cases. *** - *YouTube Video Details Scraper is the most comprehensive, structured way to extract YouTube video metadata and transcript timestamps at scale.* - *Get started now and turn video URLs into analysis-ready data with this SEO-optimized YouTube Video Details Scraper.* ### Disclaimer **This tool only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages. It is your responsibility to comply with applicable laws and regulations (including GDPR, CCPA where relevant), as well as platform terms of service and any anti-spam requirements. For data removal requests, contact . Please use this tool responsibly, ethically, and for legitimate purposes only. # Actor input Schema ## `startUrls` (type: `array`): List of YouTube video URLs to scrape. ## Actor input object example ```json { "startUrls": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ] } ``` # 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=dQw4w9WgXcQ" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("solid-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=dQw4w9WgXcQ" }] } # Run the Actor and wait for it to finish run = client.actor("solid-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("💾 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": [ { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" } ] }' | apify call solid-scraper/youtube-video-details-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=solid-scraper/youtube-video-details-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Youtube Video Details Scraper", "description": "🎥 YouTube Video Details Scraper extracts titles, views, tags & more in seconds. ⚡ Save time, boost SEO research, and grow smarter content strategies with organized results. Perfect for creators, marketers & data teams! 🚀", "version": "0.1", "x-build-id": "ylp4l6zxkdSxchH0k" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/solid-scraper~youtube-video-details-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-solid-scraper-youtube-video-details-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/solid-scraper~youtube-video-details-scraper/runs": { "post": { "operationId": "runs-sync-solid-scraper-youtube-video-details-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/solid-scraper~youtube-video-details-scraper/run-sync": { "post": { "operationId": "run-sync-solid-scraper-youtube-video-details-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": "YouTube Video URLs", "type": "array", "description": "List of YouTube video URLs to scrape.", "items": { "type": "object", "required": [ "url" ], "properties": { "url": { "type": "string", "title": "URL of a web page", "format": "uri" } } } } } }, "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 } } } } } } } } } } ```