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

YouTube Video Details Scraper extracts metadata from public YouTube videos, including title, description, channel name, view count, likes, tags, upload date, and more. Ideal for research, SEO, analytics, or automation—just input video URLs and get structured data effortlessly.

- **URL**: https://beta-securitybyobscurity.apify.com/scraper-engine/youtube-video-details-scraper.md
- **Developed by:** [Scraper Engine](https://beta-securitybyobscurity.apify.com/scraper-engine) (community)
- **Categories:** Social media, Videos
- **Stats:** 8 total users, 8 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 results

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for dataset items the Actor outputs.

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

# README

### What is YouTube Video Details Scraper?

A YouTube Video Details Scraper is a tool that automatically collects public video data such as titles, descriptions, tags, views, likes, and channel information. Instead of manually copying details, the scraper extracts structured data at scale.

It’s often called a youtube video info scraper, scraper video, or apify youtube scraper, and falls under the broader process of youtube scraping. Manual collection is slow, inconsistent, and prone to errors. Automated scraping is faster, reliable, and lets you process thousands of videos in one run, making it essential for research, analytics, and competitive insights.

### What YouTube Video Details Can You Extract?

###

| Data Point | Description |
| --- | --- |
| Video Title | Full video name for identification and SEO research. |
| Description Box | Extract text from the YouTube video description box kunda including links, credits, and metadata. |
| Tags & Hashtags | Collect keywords with youtube video tag show for topic and ranking analysis. |
| Views & Likes | Engagement stats showing popularity and audience interest. |
| Comments Count | Track audience activity and discussion volume. |
| Channel Info | Get channel name, URL, and subscriber counts. |
| Upload Date & Duration | Metadata about when the video was published and its length. |
| Thumbnails | Download image assets in multiple resolutions. |

#### Key Features of YouTube Video Details Scraper

A YouTube Video Details Scraper comes packed with features that make extracting video data simple, fast, and scalable.

- Integration Ready – Works seamlessly with YouTube scraper Python scripts and open-source GitHub projects, making it flexible for developers.

- Multiple Platforms – Use it as a chrome extension, lightweight app, or fully hosted online tool depending on your workflow.

- Bulk Scraping – Collect details from single videos, full playlists, or even search results in one run.

- Export Options – Save your results in structured formats like JSON, CSV, or Excel for smooth integration with analytics tools, CRMs, or databases.

- Proxy Support – Built-in proxy rotation ensures stability, reduces risk of blocks, and helps maintain uninterrupted scraping at scale.

These features make the scraper useful for marketers, researchers, and content creators who want reliable access to YouTube metadata without the limits of the official API.

### How to Use YouTube Video Details Scraper

Whether you’re using a hosted platform or running a YouTube scraper Python script, the setup is quick and simple. Follow these steps:

#### 1. Create an Account

Sign up on a platform like Apify to access ready-made actors such as the YouTube Video Details Scraper. Some free or online scrapers also work without registration.

#### 2. Open the Scraper Tool

Locate the YouTube scraper in your dashboard, or install it locally via GitHub/CLI. You’ll also find options like chrome extension or app-based scrapers.

#### 3. Input YouTube URLs or Search Terms

Paste one or more video links, playlists, or channel URLs into the input field. Some setups allow youtube search + action + screenshot workflows for more flexible scraping.

#### 4. Start the Scraper

Click Start/Run and the scraper will collect metadata, tags, views, likes, comments, and channel details.

#### 5. Download the Results

Once complete, export your data in CSV, Excel, JSON, or XML. Depending on your setup, you can also use a youtube video details scraper download, online tool, or API integration.

### Input

```json
{
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "startUrls": [
        {
            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
            "method": "GET"
        }
    ]
}

```

### Output

```json

[
  {
    "video_id": "dQw4w9WgXcQ",
    "title": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
    "channel_name": "Rick Astley",
    "views": 1687264439,
    "likes": 18517639,
    "published_date": "2009-10-25",
    "duration_seconds": 213,
    "engagement_rate": 0.0124,
    "transcript_available": true,
    "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  }
]

```

### 🎯 Use Cases

A YouTube Video Details Scraper is more than just a data tool — it’s a versatile solution that fits many workflows. Here are some of the most practical use cases:

#### 1. Content Research

Creators and agencies can analyze trending videos, hashtags, and engagement metrics to understand what audiences respond to. Instead of guessing, you’ll see real performance data.

#### 2. SEO Optimization

Scraping titles, tags, and descriptions helps you uncover keywords competitors use. This makes it easier to optimize your own video metadata and improve ranking in YouTube search.

#### 3. Brand Monitoring

Companies can track brand mentions across thousands of videos. A scraper pulls mentions from descriptions, comments, or tags, providing a clearer view of brand reputation on YouTube.

#### 4. Academic & Media Research

Researchers can collect large datasets for analyzing digital culture, audience behavior, or misinformation trends. With bulk exports, YouTube scraping offers structured data at scale.

#### 5. Competitor Tracking

Businesses and creators can monitor competitor channels, measuring growth, engagement, and publishing frequency. The insights allow smarter strategic planning and better content timing.

### How Many Results Can You Scrape with YouTube Video Details Scraper?

The YouTube Video Details Scraper is designed to handle everything from a single video to bulk datasets. Whether you’re analyzing one trending clip or building a research library of thousands, the scraper scales with your needs.

- Single Video – Ideal for quick analysis of metadata like title, description, views, and tags.

- Playlists – Scrape dozens or hundreds of videos at once by providing a playlist URL. This is perfect for educational series, music collections, or competitor channels.

- Search Results – Instead of clicking page by page, you can scrape hundreds of videos directly from YouTube search queries.

- Bulk Scraping – With the right setup, you can process thousands of videos in a single run, especially if you integrate proxies for stability.

The exact limits depend on your scraping plan, concurrency setup, and proxy configuration. Free tools may limit results, while hosted platforms like Apify YouTube scraper can scale much higher.

For example, a standard run can easily process 1,000+ videos at once, while optimized proxy-supported runs can extract tens of thousands without interruptions.

### How Much Will Scraping YouTube Video Details Cost?

The cost of scraping YouTube data depends on whether you use free DIY tools or a paid SaaS solution. Both options work, but they cater to different needs and levels of expertise.

- Free / DIY Tools\
  You can find open-source options like YouTube scraper GitHub projects or custom YouTube scraper Python scripts. These are completely free to use but require setup, coding knowledge, and ongoing maintenance. You’ll also need to handle updates manually when YouTube changes its layout. Free tools are great for small-scale tasks but may struggle with reliability at scale.

- Paid SaaS Platforms\
  Services like the Apify YouTube scraper start from $5 per month. With this option, you get a hosted, always-updated scraper that handles scaling, proxies, and structured exports. Paid solutions save you time, ensure stability, and allow you to scrape thousands of videos seamlessly.

### Is it Legal to Scrape YouTube Video Details?

The legality of scraping YouTube depends on what type of data you’re collecting and how you use it.

#### ✅ Public Video Metadata is Allowed

You can safely extract publicly available information such as video titles, descriptions, view counts, likes, upload dates, hashtags, and channel names. These are visible to any YouTube visitor and generally fall under fair-use data gathering. Many businesses and researchers rely on this kind of information for analysis, reporting, or SEO optimization.

#### ❌ Private or Hidden Data is Not Allowed

You cannot access or scrape data that is not publicly available, such as private videos, hidden subscriber lists, copyrighted transcripts, or personal user data. Collecting this type of information violates both YouTube’s Terms of Service and data protection laws like GDPR.

⚖️ Best Practices for Compliance

- Always respect YouTube ToS and avoid bypassing security measures.

- Do not scrape copyrighted content (e.g., full videos, restricted music).

- Use data ethically—avoid spamming, reselling, or redistributing scraped content without permission.

- Follow robots.txt and rate limits to prevent server strain.

### What Are Other YouTube Scraping Tools?

If you want to collect specific YouTube data, you don’t always need a full YouTube Video Details Scraper. There are several other specialized tools designed to target different types of information. These scrapers save time, reduce complexity, and give you focused results depending on your project.

Here’s a quick look at some popular alternatives:

| Tool | Purpose | Example Use Case |
| --- | --- | --- |
| YouTube Comments Scraper | Extracts audience comments, usernames, timestamps | Sentiment analysis, feedback mining |
| YouTube Most Replayed Scraper | Collects “most replayed” segments & heatmaps | Identify highlights for editing or engagement insights |
| YouTube Transcript Scraper | Fetches video subtitles in multiple languages | Content analysis, SEO keyword research |
| YouTube Playlist/Channel Scraper | Scrapes bulk video data from playlists or full channels | Competitor analysis, catalog building |
| YouTube Dataviewer | Provides metadata snapshots for individual videos | Verification, fact-checking, or academic research |

### FAQ – YouTube Video Details Scraper

#### Can I scrape dislikes?

No. YouTube removed public dislike counts in 2021, so they can’t be scraped. Only likes, comments, and other metrics remain available.

#### How to scrape YouTube videos at scale?

Use bulk input with playlists, search results, or channels. Combine with proxies to avoid limits and ensure smoother large-scale scraping.

#### Is there a YouTube video details scraper app or Chrome extension?

Yes. You can find lightweight browser extensions and online tools, but they usually have limits. Full scrapers like Apify YouTube Scraper are more scalable.

#### What’s the difference between free GitHub scripts vs Apify YouTube scraper?

Free GitHub scripts or Python tools are DIY—good for coders but require setup and maintenance. Apify offers a managed solution that’s faster, hosted, and updated automatically.

#### Can I integrate with other apps?

Yes. You can connect results to tools like Google Sheets, Zapier, Make, or CRMs. Many scrapers also support API/webhook integration.

#### How safe is YouTube scraping for research?

Scraping public metadata is safe and commonly used in academia or marketing. Just avoid private data and always follow YouTube’s Terms of Service.

# Actor input Schema

## `urls` (type: `array`):

Provide video or channel URLs. You can paste multiple, add one-by-one, or load a plaintext list via Requests From URL.

## `language` (type: `string`):

IETF language code used to pick subtitles/auto-captions (e.g., en, es, fr).

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

Leave empty to start without a proxy. If the target blocks, the actor will fall back to Apify Residential and continue.

## `maxRetries` (type: `integer`):

How many attempts to make per URL before recording an error.

## `requestTimeoutSec` (type: `integer`):

Timeout for HTTP requests and transcript downloads.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "language": "en",
  "proxyConfiguration": {},
  "maxRetries": 3,
  "requestTimeoutSec": 30
}
```

# 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 = {
    "urls": [
        {
            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/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 = { "urls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/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 '{
  "urls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ]
}' |
apify call scraper-engine/youtube-video-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Video Details Scraper",
        "description": "YouTube Video Details Scraper extracts metadata from public YouTube videos, including title, description, channel name, view count, likes, tags, upload date, and more. Ideal for research, SEO, analytics, or automation—just input video URLs and get structured data effortlessly.",
        "version": "0.1",
        "x-build-id": "goKx9eBI6gNHpbgaa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~youtube-video-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~youtube-video-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~youtube-video-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube URLs",
                        "type": "array",
                        "description": "Provide video or channel URLs. You can paste multiple, add one-by-one, or load a plaintext list via Requests From URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Preferred transcript language",
                        "type": "string",
                        "description": "IETF language code used to pick subtitles/auto-captions (e.g., en, es, fr).",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Leave empty to start without a proxy. If the target blocks, the actor will fall back to Apify Residential and continue.",
                        "default": {}
                    },
                    "maxRetries": {
                        "title": "Max retries per URL",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many attempts to make per URL before recording an error.",
                        "default": 3
                    },
                    "requestTimeoutSec": {
                        "title": "HTTP timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for HTTP requests and transcript downloads.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
