# YouTube Scraper (`scrapeforge/youtube-scraper`) Actor

Scrape YouTube videos, channels, playlists, and trending. Search by keyword, handle, or URL. Get titles, views, likes, descriptions, tags, and more. Fast, reliable, and export to JSON, CSV, or Excel.

- **URL**: https://apify.com/scrapeforge/youtube-scraper.md
- **Developed by:** [ScrapeForge](https://apify.com/scrapeforge) (community)
- **Categories:** Social media, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.38 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper

Scrape YouTube videos, channels, and playlists at scale. Extract rich metadata including titles, descriptions, views, likes, comments, tags, thumbnails, and more.

### Features

- **Search by keywords** - Find videos by any search query with sorting options (relevance, date, views, rating)
- **Channel scraping** - Extract videos from any channel using @handle, channel URL, or channel ID
- **Playlist extraction** - Get all videos from any public playlist
- **Direct URLs** - Scrape specific video or shorts URLs
- **Shorts support** - Include YouTube Shorts when scraping channels

### Input

| Field | Type | Description |
|-------|------|-------------|
| `startUrls` | array | YouTube URLs to scrape (auto-detects type: video, channel, playlist, search) |
| `youtubeHandles` | array | Channel handles (@user), channel IDs, or channel URLs |
| `keywords` | array | Keywords to search for on YouTube |
| `sort` | string | Sort order: relevance, date, views, or rating |
| `includeShorts` | boolean | Include YouTube Shorts when scraping channels |
| `gl` | string | Country code (e.g., US, ES, BR) for search results |
| `maxResults` | integer | Maximum total results (default: 50, min: 50, max: 10,000) |
| `maxResultsPerChannel` | integer | Maximum videos per channel (default: 30, max: 5,000) |

### Output

Each result contains:

| Field | Type | Description |
|-------|------|-------------|
| `videoId` | string | YouTube video ID |
| `title` | string | Video title |
| `description` | string | Full video description |
| `url` | string | Video URL |
| `thumbnailUrl` | string | High-resolution thumbnail URL |
| `duration` | integer | Duration in seconds |
| `uploadDate` | string | Upload date (ISO format) |
| `category` | string | Video category |
| `tags` | array | Video tags |
| `viewCount` | integer | Number of views |
| `likeCount` | integer | Number of likes |
| `commentsCount` | integer | Number of comments |
| `channelName` | string | Channel name |
| `channelId` | string | Channel ID |
| `channelUrl` | string | Channel URL |
| `subscriberCount` | integer | Channel subscriber count |
| `isShort` | boolean | Whether the video is a YouTube Short |

### Usage examples

#### Search for videos

```json
{
    "keywords": ["web scraping tutorial", "python automation"],
    "maxResults": 200,
    "sort": "relevance"
}
````

#### Scrape channels

```json
{
    "youtubeHandles": ["@MrBeast", "@PewDiePie"],
    "maxResultsPerChannel": 50,
    "includeShorts": false
}
```

#### Scrape specific URLs

```json
{
    "startUrls": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "https://www.youtube.com/@MrBeast",
        "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf"
    ]
}
```

### Export

Results can be exported to JSON, CSV, Excel, or accessed via the Apify API and integrations (Google Sheets, Zapier, Make, etc.).

### Limits

- Minimum 50 results per run
- Maximum 10,000 results per run
- Maximum 5,000 videos per channel
- No login required

### Disclaimer

This is an **unofficial** actor and is **not affiliated with, endorsed by, or sponsored by YouTube or Google**. It is developed and maintained independently. YouTube is a trademark of Google LLC.

This actor accesses only publicly available data. Users are responsible for ensuring their use complies with YouTube's Terms of Service and all applicable laws. By using this actor, you agree that you are solely responsible for how you use the extracted data.

# Actor input Schema

## `startUrls` (type: `array`):

YouTube URLs to scrape. Auto-detects type: video, channel, playlist, shorts, or search. When provided, other modes still run too.

## `youtubeHandles` (type: `array`):

Channel handles (@user), channel IDs, or channel URLs to scrape videos from.

## `keywords` (type: `array`):

Keywords to search for on YouTube.

## `sort` (type: `string`):

Sort order for search results or channel videos.

## `includeShorts` (type: `boolean`):

Include YouTube Shorts when scraping channels.

## `gl` (type: `string`):

Country code for geolocation (e.g., US, ES, BR). Used for search results.

## `maxResults` (type: `integer`):

Maximum total number of results to return. Minimum 50 per run.

## `maxResultsPerChannel` (type: `integer`):

Maximum number of videos per channel.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "https://www.youtube.com/@MrBeast",
    "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf",
    "https://www.youtube.com/results?search_query=python+tutorial"
  ],
  "youtubeHandles": [
    "@MrBeast",
    "UCX6OQ3DkcsbYNE6H8uQQuVA"
  ],
  "keywords": [
    "web scraping tutorial",
    "python automation"
  ],
  "sort": "relevance",
  "includeShorts": false,
  "gl": "US",
  "maxResults": 50,
  "maxResultsPerChannel": 30
}
```

# Actor output Schema

## `videos` (type: `string`):

Dataset containing scraped video metadata (videoId, title, description, views, likes, comments, channel info, etc.)

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeforge/youtube-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapeforge/youtube-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 '{}' |
apify call scrapeforge/youtube-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Scraper",
        "description": "Scrape YouTube videos, channels, playlists, and trending. Search by keyword, handle, or URL. Get titles, views, likes, descriptions, tags, and more. Fast, reliable, and export to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "jGLEIzW6vqPxNBp4I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeforge~youtube-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeforge-youtube-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/scrapeforge~youtube-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeforge-youtube-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/scrapeforge~youtube-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeforge-youtube-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "YouTube URLs to scrape. Auto-detects type: video, channel, playlist, shorts, or search. When provided, other modes still run too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "youtubeHandles": {
                        "title": "YouTube Channels",
                        "type": "array",
                        "description": "Channel handles (@user), channel IDs, or channel URLs to scrape videos from.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for on YouTube.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date",
                            "views",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Sort order for search results or channel videos.",
                        "default": "relevance"
                    },
                    "includeShorts": {
                        "title": "Include Shorts",
                        "type": "boolean",
                        "description": "Include YouTube Shorts when scraping channels.",
                        "default": false
                    },
                    "gl": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country code for geolocation (e.g., US, ES, BR). Used for search results.",
                        "default": "US"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 50,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total number of results to return. Minimum 50 per run.",
                        "default": 50
                    },
                    "maxResultsPerChannel": {
                        "title": "Max Results Per Channel",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of videos per channel.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
