# Youtube Video Details Scraper (`scraperoka/youtube-video-details-scraper`) Actor

🔍 YouTube Video Details Scraper extracts titles, descriptions, tags, views, likes, comments & more from any channel. ⚡ Great for creators, marketers & B2B research—save time, gather insights, and scale analysis easily. 📈

- **URL**: https://apify.com/scraperoka/youtube-video-details-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Developer tools, Automation, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 <dataforleads@gmail.com>

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 <dataforleads@gmail.com>. 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_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("scraperoka/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# 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("scraperoka/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 scraperoka/youtube-video-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/PNE7NbJFvgC2GASZN/builds/k9xKPba6F17JXigDy/openapi.json