# YouTube Video Transcript and Subtitles Scraper API (`george.the.developer/youtube-transcript-scraper`) Actor

YouTube video transcript scraper and subtitles API. Get transcripts, captions, timestamps and video metadata in bulk from videos, Shorts, playlists and channels. Pay per video, no API key needed. Callable from any MCP client such as Claude, Cursor or ChatGPT. Built for RAG and LLM datasets.

- **URL**: https://apify.com/george.the.developer/youtube-transcript-scraper.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** AI, Videos, Developer tools
- **Features:** Limited permissions
- **Stats:** 429 total users, 12 monthly users, 99.8% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 transcript extracteds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

YouTube Transcript and Subtitles Scraper API is an Apify Actor that extracts transcripts, subtitles, timed caption segments and video metadata from YouTube videos, playlists, channels and Shorts, and returns them as structured JSON. It reads YouTube caption tracks directly, so you need no API key and no YouTube Data API quota. It works as a bulk YouTube transcript API and YouTube subtitles scraper for RAG datasets, LLM training corpora, content repurposing and video SEO analysis.

> **No API key. No YouTube Data API quota. No monthly subscription.** Official-API tools burn quota and miss auto-generated captions; this scraper reads YouTube's caption tracks directly.
> You pay per extracted transcript. Videos with no captions at all never trigger a per-transcript charge.

✅ Auto-generated + manual captions · ✅ Playlists, channels, Shorts · ✅ Language fallback · ✅ Up to 5,000 videos per run · ✅ **$1 per 1,000 transcripts** · ✅ MCP ready for AI agents

### Pricing

| Event | Price | You pay when |
|---|---|---|
| Actor start | $0.0001 | Once per run |
| Transcript extracted | $0.001 | Per video transcript successfully extracted |

**$1 per 1,000 transcripts.** The start fee is a hundredth of a cent. A 500-video channel costs about $0.50. No API key, no quota, no subscription — pay only for transcripts you actually receive.

### Why this Actor?

- **Zero setup friction** — no Google Cloud project, no OAuth, no API quota limits.
- **Bulk by default** — up to 5,000 videos per run; mix video URLs, playlist URLs, channel URLs, Shorts, and raw IDs in one input.
- **Auto-generated caption support** — works even when the creator never uploaded manual subtitles.
- **Language fallback** — ask for `en`, and if it doesn't exist you still get the best available track instead of an empty row.
- **LLM-ready output** — full text, timestamped segments, or both, plus title/channel/views/duration metadata on every row.
- **Loss-leader pricing** — $1 per 1,000 transcripts.

### How it works

```mermaid
flowchart LR
    A[Video, playlist,<br/>channel, Shorts URL] --> B[Normalize URL<br/>and discover videos]
    B --> C[Fetch transcript tracks<br/>manual or auto captions]
    C --> D{Preferred language<br/>available?}
    D -- yes --> E[Extract selected<br/>language transcript]
    D -- no --> F[Fallback to best<br/>available captions]
    E --> G[Format output<br/>full text, segments, or both]
    F --> G
    G --> H[Attach metadata<br/>title, channel, views,<br/>duration, thumbnail]
    H --> I[Dataset export<br/>JSON, CSV, Excel, API]
```

### What data does it extract?

- **Full transcript text** — complete spoken content as plain text
- **Timed segments** — caption segments with start time, end time, and duration
- **Video metadata** — title, channel name, view count, upload date, duration, description, thumbnail URL
- **Language** — detected or selected transcript language
- **Video URL** — direct link to the source video

### What is NOT returned

- ❌ Video or audio files — this extracts text, not media
- ❌ Comments or community posts
- ❌ Machine translation — you get the caption tracks YouTube actually serves, in their original languages
- ❌ Burned-in (hardcoded) subtitles — text rendered into the video image has no caption track to read

### Quick start

1. Open the [YouTube Transcript Scraper](https://apify.com/george.the.developer/youtube-transcript-scraper) on Apify Store and click **Try for free**.
2. Paste video URLs, playlist URLs, channel URLs, or raw video IDs into **URLs** — formats can be mixed.
3. Pick a **Language** (default `en`; falls back automatically), an **Output Format** (`full-text`, `segments`, or `both`), and toggle timestamps/metadata.
4. Click **Start**, then export the dataset as JSON, CSV, or Excel — or pull it via API.

### Input parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `urls` | Array | Yes | YouTube video URLs, playlist URLs, channel URLs, or video IDs |
| `language` | String | No | Preferred transcript language code (default: `en`) |
| `outputFormat` | Enum | No | `full-text`, `segments`, or `both` (default: `both`) |
| `includeTimestamps` | Boolean | No | Include start/end times for each segment (default: `true`) |
| `maxVideos` | Integer | No | Maximum videos to process, up to 5,000 (default: 50) |
| `includeMetadata` | Boolean | No | Include video title, channel, views, etc. (default: `true`) |
| `maxConcurrency` | Integer | No | Concurrent requests, 1-20 (default: 5) |
| `proxyConfiguration` | Object | No | Apify Proxy country routing only. The actor always uses `BUYPROXIES94952`; custom proxy URLs and alternate groups are ignored |

### Output example

```json
{
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "How to Build a RAG Pipeline in 2026",
  "channel": "AI Engineering Academy",
  "viewCount": 245000,
  "uploadDate": "2026-02-15",
  "duration": "14:32",
  "language": "en",
  "fullText": "Welcome to this tutorial on building a retrieval-augmented generation pipeline. Today we'll cover vector databases, embedding models, and...",
  "segments": [
    {
      "text": "Welcome to this tutorial on building a retrieval-augmented generation pipeline.",
      "start": 0.0,
      "end": 4.2,
      "duration": 4.2
    },
    {
      "text": "Today we'll cover vector databases, embedding models, and chunking strategies.",
      "start": 4.2,
      "end": 8.8,
      "duration": 4.6
    }
  ],
  "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg"
}
```

### Use from Claude, ChatGPT and any MCP agent

Add this actor to any MCP client (Claude, Cursor, ChatGPT) through the Apify MCP server:

```
https://mcp.apify.com/?tools=george.the.developer/youtube-transcript-scraper
```

Or call it programmatically:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('george.the.developer/youtube-transcript-scraper').call({
    urls: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
    outputFormat: 'both',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
// items[0].fullText, items[0].segments
```

```bash
curl -X POST "https://api.apify.com/v2/acts/george.the.developer~youtube-transcript-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"]}'
```

### Integrations

- **n8n** — add the **Apify** node → operation *Run Actor and Get Dataset Items* → actor `george.the.developer/youtube-transcript-scraper` → map `fullText` into your workflow.
- **Make / Zapier** — use the Apify app's *Run Actor* module, then *Get Dataset Items*.
- **Anything else** — every run's dataset has a stable URL: `https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&format=json&clean=1`.

### AI and content pipeline

```mermaid
flowchart TD
    YT[YouTube videos] --> TR[Transcript extraction]
    TR --> CLEAN[Clean text + timestamps]
    CLEAN --> RAG[RAG / vector database]
    CLEAN --> SEO[Video SEO analysis]
    CLEAN --> REP[Blog posts, newsletters,<br/>show notes, clips]
    RAG --> APP[Chatbot or research assistant]
    SEO --> PLAN[Keyword and topic gaps]
    REP --> CMS[CMS / social scheduler]
```

### Use cases

1. **RAG and LLM fine-tuning** — turn hundreds of domain videos into a knowledge base or training corpus.
2. **Content repurposing at scale** — one video becomes blog posts, threads, newsletters, show notes.
3. **Video SEO and competitor analysis** — mine top-ranking videos' spoken content for keyword and topic gaps.
4. **Podcast and webinar archives** — long-form recordings become timestamped searchable text.
5. **Creator research and clipping** — find recurring hooks and send timestamped sections to editors or AI agents.

### FAQ

#### Do I need a YouTube Data API key?

No. This scraper works without any API key or Google account. It reads caption tracks directly, so YouTube API quotas never apply.

#### How much does it cost to transcribe 1,000 videos?

$1. Pricing is $0.001 per extracted transcript plus a $0.0001 run-start fee. Videos without captions never trigger a per-transcript charge.

#### Does it work with auto-generated captions?

Yes. Both manually uploaded subtitles and YouTube's auto-generated captions are supported, in any language YouTube serves.

#### Can I scrape entire playlists or channels?

Yes. Pass a playlist or channel URL and the scraper discovers and processes every video, up to your `maxVideos` limit (max 5,000 per run).

#### What languages are supported?

Every language YouTube provides a caption track for. Set your preferred language code; if it isn't available the scraper falls back to the best available track instead of returning nothing.

#### How do I handle geo-restricted videos?

Set `proxyConfiguration.countryCode` to route through Apify Proxy in the right country. The actor always enforces the `BUYPROXIES94952` proxy group for reliability.

#### Can I use the output for LLM training data?

Yes. The `full-text` format is designed for direct ingestion into fine-tuning and RAG pipelines; process up to 5,000 videos per run to build large corpora.

#### Which output formats can I choose?

Set `outputFormat` to `full-text` for the transcript as one string, `segments` for the list of timed segments, or `both`, which is the default. Timestamps are included on each segment unless you turn `includeTimestamps` off. Video metadata such as title, channel, view count and duration comes with `includeMetadata`, which is also on by default.

#### Can an AI agent call this actor?

Yes. Add it to any MCP client, such as Claude, Cursor or ChatGPT, through the Apify MCP server at `https://mcp.apify.com/?tools=george.the.developer/youtube-transcript-scraper`. It also runs from the Apify API with curl or from JavaScript with `apify-client`, as the examples above show.

# Actor input Schema

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

List of YouTube video URLs, playlist URLs, or channel URLs. Supports: youtube.com/watch?v=, youtu.be/, youtube.com/playlist?list=, youtube.com/@channel, youtube.com/shorts/

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

Preferred transcript language code (e.g., 'en', 'es', 'fr', 'de', 'ja'). Falls back to auto-generated captions if manual captions unavailable. Leave empty for default language.

## `includeTimestamps` (type: `boolean`):

Include start time and duration for each transcript segment. Useful for building video indexes or jumping to specific parts.

## `outputFormat` (type: `string`):

How to format the transcript text. 'full-text' = single concatenated string (best for AI/LLM input). 'segments' = array of timestamped segments. 'both' = includes both formats.

## `maxVideos` (type: `integer`):

Maximum number of videos to process. Useful when scraping playlists or channels to limit costs.

## `includeMetadata` (type: `boolean`):

Include video title, channel name, description, view count, publish date, duration, and tags alongside the transcript.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent requests. Higher = faster but more likely to hit rate limits.

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

Apify Proxy country routing only. This actor always uses BUYPROXIES94952; custom proxy URLs and alternate groups are ignored.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "language": "en",
  "includeTimestamps": true,
  "outputFormat": "both",
  "maxVideos": 50,
  "includeMetadata": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Rows of this run's dataset in the Overview table view, with video id, title, channel, language and transcript.

# 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": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/youtube-transcript-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": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/youtube-transcript-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call george.the.developer/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/youtube-transcript-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jTeLbWgPzyrAlUqWC/builds/5MhssVcMfx6UeXfXn/openapi.json