# Youtube Transcript Scraper (`parseforge/youtube-transcript-scraper`) Actor

Pull transcripts from any YouTube video at scale! Extract full subtitles with timestamps in SRT and plain text, plus titles, channels, descriptions, view counts, upload dates, tags, and thumbnails. Perfect for content research, SEO, summarization, and video analytics. Start extracting today!

- **URL**: https://apify.com/parseforge/youtube-transcript-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎬 YouTube Transcript Scraper

> 🚀 **Extract full transcripts from any YouTube video in seconds.** Timestamped segments, **SRT export**, and 17 metadata fields (title, channel, views, likes, upload date, tags, thumbnail) per video. No API key, no registration, no YouTube Data API quota.

> 🕒 **Last updated:** 2026-04-24 · **📊 17 fields** per video · **🌐 100+ languages** · **⚡ 30 videos in parallel** · **📜 SRT + plain text output**

The **YouTube Transcript Scraper** turns any YouTube URL into a structured record with the full transcript, segment timestamps, and 17 metadata fields. It handles human-authored captions and auto-generated ones across 100+ languages. Each record ships with the plain-text transcript, an SRT file for subtitle overlay, and a segment array for timestamp-precise search.

Metadata covers title, channel ID, channel name, channel URL, description, duration, view count, like count, comment count, upload date, tags, categories, thumbnail URL, and the list of all available subtitle languages. Concurrent extraction keeps 30 videos processing in parallel, so a queue of 100 clips finishes in a couple of minutes. Residential proxy is required because YouTube has cracked down hard on datacenter IPs.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| AI app developers, researchers, content creators, language learners, accessibility engineers, journalists | RAG video indexing, LLM summarization, captions datasets, language learning, accessibility tools |

---

### 📋 What the YouTube Transcript Scraper does

Six transcript workflows in a single run:

- 📝 **Full transcript.** Timestamped segments with start, duration, and text per line.
- 💬 **Plain text transcript.** Flat string ready for LLM ingestion.
- 🎞️ **SRT export.** Standards-compliant subtitle file for video apps.
- 🌐 **Language picker.** Choose your preferred caption language with fallback to defaults.
- 🎬 **Video metadata.** Title, channel info, views, likes, comments, upload date, tags, categories.
- 🌍 **Available languages.** Full list of manual and auto-generated caption languages per video.

Each record also includes the thumbnail URL and an `isAutoGenerated` flag so you can filter out auto captions when you need human-quality transcripts.

> 💡 **Why it matters:** video is the largest untapped dataset in the world. Transcripts make it searchable, summarizable, and indexable. DIY transcript fetchers break every time YouTube changes their API. This Actor uses yt-dlp under the hood, which is actively maintained.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough of transcript-powered video search._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>startUrls</code></td><td>array of URLs</td><td>required if no videoIds</td><td>YouTube video URLs (<code>youtube.com/watch?v=</code>, <code>youtu.be/</code>, shorts).</td></tr>
<tr><td><code>videoIds</code></td><td>array of strings</td><td>required if no startUrls</td><td>Raw YouTube video IDs (11 chars).</td></tr>
<tr><td><code>language</code></td><td>string</td><td><code>""</code></td><td>Preferred ISO language code (<code>en</code>, <code>es</code>, <code>fr</code>).</td></tr>
<tr><td><code>includeAutoGenerated</code></td><td>boolean</td><td><code>true</code></td><td>Fall back to auto-generated captions when no manual ones exist.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Videos processed. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>proxyConfiguration</code></td><td>object</td><td>RESIDENTIAL</td><td>Residential proxy required.</td></tr>
</tbody>
</table>

**Example: transcribe a TED talk.**

```json
{
    "startUrls": [
        { "url": "https://www.youtube.com/watch?v=UyyjU8fzEYU" }
    ],
    "language": "en",
    "includeAutoGenerated": true,
    "maxItems": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

**Example: batch transcribe a playlist of videos.**

```json
{
    "videoIds": [
        "dQw4w9WgXcQ",
        "kJQP7kiw5Fk",
        "9bZkp7q19f0"
    ],
    "language": "en",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** YouTube now blocks datacenter IPs for transcript fetching. Apify residential proxy is included on paid plans and is strongly recommended. Videos without captions return a record with an `error` field explaining "No subtitles available."

***

### 📊 Output

Each record contains **17 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `videoId` | string | `"UyyjU8fzEYU"` |
| 🔗 `url` | string | `"https://www.youtube.com/watch?v=UyyjU8fzEYU"` |
| 🏷️ `title` | string | null | `"My stroke of insight | Jill Bolte Taylor | TED"` |
| 🆔 `channelId` | string | null | `"UCAuUUnT6oDeKwE6v1NGQxug"` |
| 🔗 `channelUrl` | string | null | `"https://www.youtube.com/channel/..."` |
| 🧑 `channelName` | string | null | `"TED"` |
| 📝 `description` | string | null | `"Neuroanatomist Jill Bolte Taylor..."` |
| ⏱️ `durationSeconds` | number | null | `1141` |
| 👁️ `viewCount` | number | null | `8688914` |
| 👍 `likeCount` | number | null | `122000` |
| 💬 `commentCount` | number | null | `4800` |
| 📅 `uploadDate` | string | null | `"2008-03-13"` |
| 🏷️ `tags` | string\[] | `["TED Talk", "brain", "science"]` |
| 🗂️ `categories` | string\[] | `["Science & Technology"]` |
| 🌐 `language` | string | null | `"en"` |
| 🌍 `availableSubtitleLanguages` | string\[] | `["en", "es", "fr"]` |
| 🤖 `availableAutoCaptionLanguages` | string\[] | `["en"]` |
| 🤖 `isAutoGenerated` | boolean | `false` |
| 📜 `transcript` | array | `[{"start": 12.3, "duration": 4.2, "text": "..."}]` |
| 💬 `transcriptPlainText` | string | `"I grew up to study the brain..."` |
| 🎞️ `transcriptSrt` | string | `"1\n00:00:12,300 --> ...\n..."` |
| 🔢 `wordCount` | number | `2703` |
| 🖼️ `thumbnailUrl` | string | null | `"https://i.ytimg.com/vi/.../maxresdefault.jpg"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-04-21T12:00:00.000Z"` |
| ❗ `error` | string | null | `"No subtitles available"` on failure |

#### 📦 Sample records

<details>
<summary><strong>🎤 TED talk with human captions</strong></summary>

```json
{
    "videoId": "UyyjU8fzEYU",
    "url": "https://www.youtube.com/watch?v=UyyjU8fzEYU",
    "title": "My stroke of insight | Jill Bolte Taylor | TED",
    "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
    "channelUrl": "https://www.youtube.com/channel/UCAuUUnT6oDeKwE6v1NGQxug",
    "channelName": "TED",
    "description": "Neuroanatomist Jill Bolte Taylor had an opportunity...",
    "durationSeconds": 1141,
    "viewCount": 8688914,
    "likeCount": 122000,
    "commentCount": 4800,
    "uploadDate": "2008-03-13",
    "tags": ["TED Talk", "brain", "science"],
    "categories": ["Science & Technology"],
    "language": "en",
    "availableSubtitleLanguages": ["en", "es", "fr", "de", "..."],
    "availableAutoCaptionLanguages": ["en"],
    "isAutoGenerated": false,
    "transcript": [
        { "start": 12.3, "duration": 4.2, "text": "I grew up to study the brain..." }
    ],
    "transcriptPlainText": "I grew up to study the brain because...",
    "transcriptSrt": "1\n00:00:12,300 --> 00:00:16,500\nI grew up to study the brain...",
    "wordCount": 2703,
    "thumbnailUrl": "https://i.ytimg.com/vi/UyyjU8fzEYU/maxresdefault.jpg",
    "scrapedAt": "2026-04-21T12:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🎵 Music video with auto-generated captions</strong></summary>

```json
{
    "videoId": "kJQP7kiw5Fk",
    "url": "https://www.youtube.com/watch?v=kJQP7kiw5Fk",
    "title": "Luis Fonsi - Despacito ft. Daddy Yankee",
    "channelName": "LuisFonsiVEVO",
    "durationSeconds": 281,
    "viewCount": 8995927889,
    "likeCount": 55000000,
    "commentCount": 3500000,
    "uploadDate": "2017-01-12",
    "tags": ["latin", "reggaeton", "despacito"],
    "categories": ["Music"],
    "language": "en-US",
    "availableSubtitleLanguages": [],
    "availableAutoCaptionLanguages": ["en"],
    "isAutoGenerated": true,
    "transcript": [{ "start": 3.5, "duration": 2.1, "text": "(music playing)" }],
    "transcriptPlainText": "(music playing) Despacito...",
    "transcriptSrt": "1\n00:00:03,500 --> ...\n(music playing)",
    "wordCount": 589,
    "thumbnailUrl": "https://i.ytimg.com/vi/kJQP7kiw5Fk/maxresdefault.jpg",
    "scrapedAt": "2026-04-21T12:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🚧 Video without captions</strong></summary>

```json
{
    "videoId": "jNQXAC9IVRw",
    "url": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "title": "Me at the zoo",
    "channelName": "jawed",
    "durationSeconds": 19,
    "viewCount": 340000000,
    "uploadDate": "2005-04-23",
    "tags": [],
    "categories": ["People & Blogs"],
    "availableSubtitleLanguages": [],
    "availableAutoCaptionLanguages": [],
    "isAutoGenerated": false,
    "transcript": [],
    "transcriptPlainText": "",
    "transcriptSrt": "",
    "wordCount": 0,
    "thumbnailUrl": "https://i.ytimg.com/vi/jNQXAC9IVRw/default.jpg",
    "scrapedAt": "2026-04-21T12:00:00.000Z",
    "error": "No subtitles available for this video"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📜 | **Full transcript + SRT.** Three output formats: segments, plain text, subtitle file. |
| 🌐 | **100+ languages.** Manual captions and auto-generated captions supported. |
| 📊 | **17 metadata fields.** Title, channel, views, likes, comments, tags, upload date. |
| ⚡ | **Concurrent.** 30 videos processing in parallel on a single run. |
| 🔁 | **Actively maintained.** Uses yt-dlp under the hood, which tracks YouTube's changes. |
| 🚫 | **No YouTube Data API quota.** Unlimited captions without Google Cloud project. |
| 🔌 | **Integrations.** Drops into RAG pipelines, language-learning apps, and subtitle tools. |

> 📊 Every transcript is a searchable index point. Indexing video at scale unlocks insights, summaries, and accessibility features that would be impossible to build manually.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ YouTube Transcript Scraper** *(this Actor)* | $5 free credit, then pay-per-use | Any public video | **Live per run** | language, auto/manual, list | ⚡ 2 min |
| YouTube Data API | Free (quota) | Metadata only | Real-time | Strict quota | ⏳ Variable |
| DIY yt-dlp scripts | Free | Whatever you code | Your schedule | Whatever you build | 🐢 Days |
| Paid transcription APIs | $0.04+/min | Any audio | Real-time | Custom filters | ⏳ Hours |

Pick this Actor when you want reliable YouTube transcripts without quota limits or custom infrastructure.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the YouTube Transcript Scraper page on the Apify Store.
3. 🎯 **Add video URLs.** Paste URLs or video IDs and pick a preferred language.
4. 🚀 **Run it.** Click **Start** and let the Actor transcribe.
5. 📥 **Download.** Grab your dataset as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded transcripts: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🧠 AI & RAG

- Index videos in a searchable knowledge base
- Feed transcripts to GPT, Claude, or Gemini summaries
- Build video-aware chatbots
- Generate research datasets for LLMs

</td>
<td width="50%" valign="top">

#### 🎓 Education & Learning

- Side-by-side bilingual transcripts
- Study notes from lecture videos
- Language-learning flashcards from music
- Accessibility captions for students

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📰 Media & Journalism

- Extract quotes from interview videos
- Fact-check statements at scale
- Build transcripts for podcast archives
- Monitor public-figure statements

</td>
<td width="50%" valign="top">

#### 🛠️ Developer Tooling

- SRT files for video players
- Transcripts for video search engines
- Subtitle generation for app content
- Dataset assembly for speech models

</td>
</tr>
</table>

***

### 🔌 Automating YouTube Transcript Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily transcription of a channel's latest uploads keeps a RAG index current.

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20YOUTUBE%20TRANSCRIPT%20SCRAPER%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20YOUTUBE%20TRANSCRIPT%20SCRAPER%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20YOUTUBE%20TRANSCRIPT%20SCRAPER%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20YOUTUBE%20TRANSCRIPT%20SCRAPER%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

The Actor wraps yt-dlp, which fetches metadata and subtitle files from YouTube. Transcripts are parsed into structured segments, then flattened into plain text and SRT formats. Each run processes up to 30 videos in parallel.

#### 📏 How accurate are the transcripts?

Human-authored captions are highly accurate. Auto-generated captions depend on the audio quality and language; English auto captions are typically 85-95% accurate.

#### 🌐 Which languages are supported?

Every language for which YouTube publishes captions or auto-captions (100+ languages). Pass any ISO code to `language` or leave empty for the video's default.

#### 🔁 Why do I need residential proxy?

YouTube now challenges datacenter IPs with "Sign in to confirm you're not a bot" when fetching metadata or subtitles. Residential proxy is included on paid Apify plans and bypasses this cleanly.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to transcribe new uploads on any cron interval.

#### ⚖️ Is it legal?

Transcript extraction from publicly available videos is generally fine for research, indexing, and AI use. Commercial redistribution of transcripts may require rights clearance from the video owner.

#### 💼 Can I use this commercially?

Yes for internal search, RAG, and summarization. Redistribution of full transcripts requires respecting copyright and YouTube's terms of service.

#### 💳 Do I need a paid Apify plan to use this Actor?

The free plan covers testing (10 videos per run). A paid plan lifts the limit AND gives you residential proxy access, which is required for reliable YouTube transcript fetching.

#### 🔁 What happens if a run fails?

Apify retries transient errors. Per-video failures (no captions, geo-blocked, private) are logged in the `error` field. Partial datasets are preserved.

#### 🎞️ Can I download the video file?

This Actor focuses on transcripts and metadata. For video files, use a dedicated YouTube Video Downloader actor.

#### 📺 Does it work on shorts, live streams, and age-restricted videos?

YouTube Shorts work. Live streams and age-restricted videos are not supported (age-restricted requires sign-in; live streams have no final transcript until the stream ends).

#### 🆘 What if I need help?

Our team is available through the Apify platform and the Tally form below.

***

### 🔌 Integrate with any app

YouTube Transcript Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Auto-transcribe new uploads
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Push transcripts to Notion or Airtable
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Share TL;DRs in team channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe transcripts into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Save transcripts to Docs or Sheets

You can also use webhooks to push transcripts into vector databases, RAG stacks, or subtitle tools.

***

### 🔗 Recommended Actors

- [**📺 YouTube Channel Scraper**](https://apify.com/parseforge/youtube-channel-scraper) - Channel metadata and video lists
- [**🎞️ YouTube Shorts Scraper**](https://apify.com/parseforge/youtube-shorts-scraper) - Shorts data and metadata
- [**💬 YouTube Comments Scraper**](https://apify.com/parseforge/youtube-comments-scraper) - Comments and replies
- [**🏷️ YouTube Hashtag Scraper**](https://apify.com/parseforge/youtube-hashtag-scraper) - Videos matching a hashtag
- [**🤖 RAG Web Browser**](https://apify.com/parseforge/rag-web-browser) - Search the web with LLM-ready output

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more video and audio tools.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with Google, YouTube, or Alphabet. It accesses only publicly available video metadata and caption tracks. Respect YouTube's terms of service and copyright when using transcripts commercially.

# Actor input Schema

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

URLs to process

## `videoIds` (type: `array`):

YouTube video IDs

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

ISO language code (en, es, fr...). Leaves empty to get the video's default.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `includeSrt` (type: `boolean`):

Include the transcript as SRT subtitle format (billed per video). Disable to return only the segmented JSON transcript.

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

Proxy to pass to yt-dlp. YouTube blocks datacenter IPs - residential proxy is required.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "maxItems": 10,
  "includeSrt": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Complete dataset

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

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/youtube-transcript-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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Transcript Scraper",
        "description": "Pull transcripts from any YouTube video at scale! Extract full subtitles with timestamps in SRT and plain text, plus titles, channels, descriptions, view counts, upload dates, tags, and thumbnails. Perfect for content research, SEO, summarization, and video analytics. Start extracting today!",
        "version": "1.0",
        "x-build-id": "yCa3XdZ7OmJbDJany"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-youtube-transcript-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/parseforge~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-youtube-transcript-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/parseforge~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-youtube-transcript-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": "Video URLs",
                        "type": "array",
                        "description": "URLs to process",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "videoIds": {
                        "title": "Video IDs",
                        "type": "array",
                        "description": "YouTube video IDs",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Preferred Language",
                        "type": "string",
                        "description": "ISO language code (en, es, fr...). Leaves empty to get the video's default."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "includeSrt": {
                        "title": "Include SRT subtitle export",
                        "type": "boolean",
                        "description": "Include the transcript as SRT subtitle format (billed per video). Disable to return only the segmented JSON transcript.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy to pass to yt-dlp. YouTube blocks datacenter IPs - residential proxy is required."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
