# YouTube Scraper — Videos, Transcripts, Comments, Channels (`hipersoft/youtube-scraper`) Actor

All-in-one YouTube API: get video metadata, full transcripts, comments with replies, channel data, and search results in a single call. No browser, no API keys, fast and cheap.

- **URL**: https://apify.com/hipersoft/youtube-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Videos, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.20 / 1,000 video scrapeds

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 Scraper — Videos, Transcripts, Comments & Channels

Extract everything from YouTube in a **single Actor**: video metadata, full **transcripts** (with timestamps), **comments** with reply threads, **channel** profiles with social links, and **search** results. No official API keys, no quotas, no browser — fast and low-cost.

Most YouTube scrapers make you run three or four separate Actors (one for metadata, one for transcripts, one for comments…) and bill you separately for each. This one does it all in one call.

### Features

- 🎥 **Video metadata** — title, description, view count, like count, duration, publish date, keywords, thumbnails
- 📝 **Transcripts** — full text, timestamped segments, and ready-to-use SRT subtitles, with language selection and auto-generated fallback
- 💬 **Comments** — top comments **including reply threads**, with author, like count, and creator/verified flags
- 📺 **Channels** — subscribers, total views, video count, country, join date, **external & social links**, and recent videos
- 🔍 **Search** — scrape YouTube search results, optionally enriched with transcripts/comments/channel data
- ⚡ **Fast & cheap** — pure HTTP (no headless browser), 512 MB, works with datacenter proxies

### Input

Provide any combination of video URLs, search queries, and channel URLs, then toggle the add-ons you want.

```json
{
  "videoUrls": ["https://www.youtube.com/watch?v=aircAruvnKk"],
  "searchQueries": ["machine learning tutorial"],
  "maxResultsPerQuery": 20,
  "channelUrls": ["https://www.youtube.com/@3blue1brown"],
  "includeTranscript": true,
  "transcriptLanguage": "en",
  "includeComments": true,
  "maxComments": 100,
  "includeChannel": true
}
````

| Field | Type | Description |
|---|---|---|
| `videoUrls` | array | Video or Shorts URLs (or bare 11-char IDs) |
| `searchQueries` | array | Search terms; results scraped as videos |
| `maxResultsPerQuery` | integer | Videos to return per search query (default 20) |
| `channelUrls` | array | Channel URLs (`@handle` or `/channel/UC…`) |
| `includeTranscript` | boolean | Attach the transcript to each video |
| `transcriptLanguage` | string | Preferred language code, e.g. `en`, `es`, `de` |
| `includeComments` | boolean | Attach comments (with replies) to each video |
| `maxComments` | integer | Max comments per video incl. replies |
| `includeChannel` | boolean | Attach the uploader's channel profile to each video |

### Output

Each video is one dataset item:

```json
{
  "type": "video",
  "id": "aircAruvnKk",
  "title": "But what is a neural network? | Deep learning chapter 1",
  "viewCount": 23621207,
  "likeCount": 551760,
  "durationSeconds": 1120,
  "publishDate": "2017-10-05T08:11:25-07:00",
  "channel": { "name": "3Blue1Brown", "subscriberCount": 8460000, "links": [ … ] },
  "transcript": {
    "available": true,
    "language": "en",
    "segments": [ { "start": 4.2, "duration": 3.1, "text": "This is a 3." } ],
    "fullText": "This is a 3. It's sloppily written …",
    "srt": "1\n00:00:04,200 --> 00:00:07,300\nThis is a 3.\n…"
  },
  "comments": [
    { "author": "@user", "text": "Great video!", "likeCount": 13000, "replies": [ … ] }
  ]
}
```

Channels and standalone search results are emitted as `type: "channel"` and `type: "search-result"` items.

### Common use cases

- **Feed transcripts to an LLM** for summaries, RAG, or content repurposing
- **Comment & sentiment analysis** on any video or channel
- **Lead generation** — pull business emails and social links from channel About pages
- **Competitor & trend research** across search results and channel catalogs

### Integration

Run it from the [Apify API](https://docs.apify.com/api/v2), the JavaScript/Python clients, or schedule it in the Apify Console. Export results as JSON, CSV, Excel, or via webhook.

### Notes

Only public data is scraped. If you hit occasional blocks at scale, enable residential proxies in the input.

# Actor input Schema

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

YouTube video or Shorts URLs (or bare video IDs). Each returns one item with metadata — plus transcript, comments, and channel info if enabled below.

## `searchQueries` (type: `array`):

Search YouTube and scrape the resulting videos (metadata only; enable add-ons below to enrich each hit).

## `maxResultsPerQuery` (type: `integer`):

How many videos to return per search query.

## `channelUrls` (type: `array`):

Channel URLs (@handle or /channel/UC… form). Returns channel metadata, links, and recent videos.

## `includeTranscript` (type: `boolean`):

Fetch the full transcript with timestamps for each video (add-on, charged per transcript).

## `transcriptLanguage` (type: `string`):

Preferred transcript language code (e.g. en, es, de). Falls back to the first available track, including auto-generated.

## `includeComments` (type: `boolean`):

Fetch top comments including reply threads for each video (add-on, charged per comment).

## `maxComments` (type: `integer`):

Upper limit of comments (incl. replies) per video.

## `includeChannel` (type: `boolean`):

Fetch the uploader channel's profile (subscribers, links, description) for each video (add-on, charged per channel).

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

Proxy to use. YouTube blocks datacenter IPs on video metadata, so residential proxies are required and set by default. Leave as-is unless you have your own proxies.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxResultsPerQuery": 20,
  "includeTranscript": true,
  "transcriptLanguage": "en",
  "includeComments": false,
  "maxComments": 100,
  "includeChannel": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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=dQw4w9WgXcQ"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Scraper — Videos, Transcripts, Comments, Channels",
        "description": "All-in-one YouTube API: get video metadata, full transcripts, comments with replies, channel data, and search results in a single call. No browser, no API keys, fast and cheap.",
        "version": "1.0",
        "x-build-id": "ZXlB6omle9T9DGq6S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hipersoft~youtube-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hipersoft-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/hipersoft~youtube-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hipersoft-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/hipersoft~youtube-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hipersoft-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": {
                    "videoUrls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "YouTube video or Shorts URLs (or bare video IDs). Each returns one item with metadata — plus transcript, comments, and channel info if enabled below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search YouTube and scrape the resulting videos (metadata only; enable add-ons below to enrich each hit).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many videos to return per search query.",
                        "default": 20
                    },
                    "channelUrls": {
                        "title": "Channel URLs",
                        "type": "array",
                        "description": "Channel URLs (@handle or /channel/UC… form). Returns channel metadata, links, and recent videos.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeTranscript": {
                        "title": "Include transcript",
                        "type": "boolean",
                        "description": "Fetch the full transcript with timestamps for each video (add-on, charged per transcript).",
                        "default": true
                    },
                    "transcriptLanguage": {
                        "title": "Transcript language",
                        "type": "string",
                        "description": "Preferred transcript language code (e.g. en, es, de). Falls back to the first available track, including auto-generated.",
                        "default": "en"
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Fetch top comments including reply threads for each video (add-on, charged per comment).",
                        "default": false
                    },
                    "maxComments": {
                        "title": "Max comments per video",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit of comments (incl. replies) per video.",
                        "default": 100
                    },
                    "includeChannel": {
                        "title": "Include channel details",
                        "type": "boolean",
                        "description": "Fetch the uploader channel's profile (subscribers, links, description) for each video (add-on, charged per channel).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy to use. YouTube blocks datacenter IPs on video metadata, so residential proxies are required and set by default. Leave as-is unless you have your own proxies.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```