# YouTube Video Metadata Scraper - Video Data (`benthepythondev/youtube-video-metadata-scraper`) Actor

Scrape metadata from YouTube video URLs: title, description, channel, views, likes, comments, duration, tags and thumbnail.

- **URL**: https://apify.com/benthepythondev/youtube-video-metadata-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Metadata Scraper - Video Data

Scrape metadata from YouTube video URLs and export clean video data in one run. Get title, description, duration, channel, channel URL, views, likes, comments, upload date, tags, categories, thumbnail and availability fields. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the YouTube Video Metadata Scraper?

The YouTube Video Metadata Scraper turns a list of public YouTube video URLs into structured rows. It is built for marketers, creators, agencies, researchers, data teams and automation builders who need reliable video metadata without setting up the official YouTube API.

The actor uses `yt-dlp` metadata extraction and does not download videos. It focuses on metadata only, which keeps runs lightweight and practical for scheduled workflows.

#### What data does it extract?

- **Video fields:** video id, URL, title, description, duration, upload date and timestamp.
- **Channel fields:** channel name, channel id, channel URL and uploader id.
- **Engagement fields:** view count, like count and comment count when available.
- **Discovery fields:** tags, categories, thumbnail, availability and live status.

### Input

Paste one or more YouTube video URLs into `videoUrls`.

#### Example input

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=K5KVEU3aaeQ",
    "https://www.youtube.com/watch?v=_uQrJ0TkZlc"
  ]
}
````

### Output

Each dataset row can include:

```json
{
  "video_id": "K5KVEU3aaeQ",
  "url": "https://www.youtube.com/watch?v=K5KVEU3aaeQ",
  "title": "Python Full Course for Beginners",
  "description": "Master Python from scratch...",
  "duration_seconds": 7341,
  "channel": "Programming with Mosh",
  "channel_id": "UCWv7vMbMWH4-V0ZXdmDpPBA",
  "channel_url": "https://www.youtube.com/channel/UCWv7vMbMWH4-V0ZXdmDpPBA",
  "uploader_id": "@programmingwithmosh",
  "view_count": 6814353,
  "like_count": 120000,
  "comment_count": 3000,
  "upload_date": "20240201",
  "tags": ["python", "programming"],
  "categories": ["Education"],
  "thumbnail": "https://i.ytimg.com/...",
  "availability": "public",
  "live_status": "not_live"
}
```

### Use cases

🎥 **Video research:** Export metadata for a set of videos and compare titles, descriptions, lengths, tags and thumbnails.

📈 **Competitive analysis:** Track competitor videos and monitor views, likes, comments and publishing patterns.

🧲 **Influencer vetting:** Collect public performance signals before reviewing creators manually.

🧠 **Content planning:** Study successful videos in a niche and build topic or format ideas.

🗂️ **Dataset enrichment:** Add YouTube metadata to URLs collected from search, playlists, RSS feeds or internal databases.

### Workflow ideas

Use this actor after a search or playlist export. First collect video URLs, then pass those URLs into this actor to enrich them with deeper metadata. For agencies, keep one task per client or niche and run it on a saved list of competitor videos. For research teams, store results over time and compare how view counts change.

The actor is also useful for cleaning messy video URL lists. It returns normalized video ids, canonical URLs and channel metadata so downstream workflows can deduplicate videos and group them by channel.

### Reliability notes

The actor does not use a YouTube API key and does not download media. YouTube can change page behavior or hide some fields depending on video, region, age restrictions or availability. Missing fields are returned as `null` rather than guessed.

For large jobs, split video URLs across several tasks. That keeps retries easy and avoids letting one unavailable video affect a very large batch.

### Data quality tips

YouTube metadata changes over time. View counts, like counts, comment counts, titles, descriptions and thumbnails can all change after a video is published. If you need monitoring, schedule repeated runs and keep the run timestamp in your own storage so you can compare snapshots.

For research datasets, deduplicate by `video_id` rather than raw URL. The same video can appear with tracking parameters, playlist parameters or shortened links. The normalized `video_id` and canonical `url` make later joins much easier.

Some videos expose limited metadata because of age restrictions, regional restrictions, privacy settings, live-stream state or YouTube page behavior. Missing fields are kept as `null`; the actor does not invent values.

### Pricing

This actor uses pay-per-result pricing. You are charged for each video metadata row pushed to the dataset, plus a tiny actor-start event.

### FAQ

#### Does it download videos?

No. It only extracts metadata.

#### Does it need a YouTube API key?

No. It uses public metadata extraction through `yt-dlp`.

#### Can I scrape multiple videos?

Yes. Add multiple URLs to `videoUrls`.

#### Does it include comments?

It may include comment count when available, but it does not scrape comment text.

#### Does it include transcripts?

No. Use a transcript actor separately if you need subtitles or captions.

#### Can I schedule it?

Yes. Save a task and run it on a schedule to monitor the same videos.

#### Is it legal?

This actor extracts publicly available metadata. You are responsible for using the output lawfully, respecting YouTube's terms, privacy rules, copyright and compliance requirements.

#### Why use this instead of the official YouTube API?

The official API is useful if you have quota and developer setup. This actor is simpler for Apify exports, no-code workflows and quick URL enrichment.

#### Can I combine this with playlist or search actors?

Yes. Use a search or playlist actor to discover URLs, then enrich those URLs here.

#### Does it work for Shorts?

It can extract metadata from many Shorts URLs, but the dedicated Shorts actor is better for monitoring a channel's Shorts tab.

#### Can I use it for reporting?

Yes. Export rows to a spreadsheet or BI tool and group by channel, category, tag, view count or upload date.

### You might also like

- YouTube Search Results Scraper - find videos by keyword
- YouTube Playlist Extractor - export playlist videos
- YouTube Shorts Scraper - monitor Shorts tabs
- YouTube Transcript Scraper - extract captions and transcript text

### Keywords

YouTube metadata scraper, YouTube video data, YouTube video API, video metadata extractor, YouTube title scraper, YouTube views scraper, YouTube channel metadata, YouTube tags extractor, creator analytics, video intelligence.

# Actor input Schema

## `videoUrls` (type: `array`):

YouTube video URLs to extract metadata from.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=K5KVEU3aaeQ"
  ]
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=K5KVEU3aaeQ"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/youtube-video-metadata-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 = { "videoUrls": ["https://www.youtube.com/watch?v=K5KVEU3aaeQ"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Video Metadata Scraper - Video Data",
        "description": "Scrape metadata from YouTube video URLs: title, description, channel, views, likes, comments, duration, tags and thumbnail.",
        "version": "1.0",
        "x-build-id": "tpmgRmj9gcg1tiCGk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~youtube-video-metadata-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-youtube-video-metadata-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/benthepythondev~youtube-video-metadata-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-youtube-video-metadata-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/benthepythondev~youtube-video-metadata-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-youtube-video-metadata-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",
                "properties": {
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "YouTube video URLs to extract metadata from.",
                        "default": [
                            "https://www.youtube.com/watch?v=K5KVEU3aaeQ"
                        ],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```