# YouTube Transcript Scraper - Timestamps, SRT and Metadata (`parseforge/youtube-transcript-scraper`) Actor

Get YouTube transcripts from video URLs or IDs: timestamped segments, plain text, word count, optional SRT, plus title, channel, views and caption languages. Creator-made captions come first. Videos without captions get a free error row. 37 of 37 test requests returned a transcript.

- **URL**: https://apify.com/parseforge/youtube-transcript-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Videos, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 56 total users, 10 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.60 / 1,000 result items

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### YouTube Transcript Scraper - Timestamps, SRT and Metadata

**Get the full transcript of any public YouTube video that has captions, from a URL or a video ID.** Each video comes back as one row with timestamped segments, the plain text, a word count, an optional SRT file and the video metadata (title, channel, duration, views, likes, upload date, tags, caption languages). You do not need an API key or a quota.

**Tested on September 24, 2026:** 37 of 37 transcript requests came back, across 10 captioned videos in 18 runs (English and Spanish, creator-made and auto-generated captions). Each run finished in 4.3 to 11.1 seconds.

**You pay only for videos that return a transcript.** A video with no captions gets a row that says why, with its metadata, and that row is free. There is no start fee.

YouTube's official API needs OAuth and quota, and it only returns captions for videos you own. This Actor reads the same caption tracks the YouTube player uses. When a video has both a creator-made track and an auto-generated one, you get the creator-made track.

| Who uses it | What they scrape YouTube for |
|---|---|
| Content marketers | Repurpose video content into blog posts, social snippets, or SEO articles |
| Market researchers | Analyze what competitors say in their videos without watching them |
| Podcast producers | Turn video interviews into searchable text and show notes |
| Data scientists | Build datasets of spoken content for NLP and sentiment analysis |
| Accessibility teams | Generate accurate captions and transcripts for video libraries |

### What it does

This Actor takes YouTube video URLs or video IDs and returns one row per video with the transcript and the video's metadata.

- 📄 **Segmented JSON transcript:** every line with its start time, duration, and text, ready for analysis.
- 🎞️ **SRT subtitle export:** optional SRT file per video, billed per video, for direct use in players.
- 🌐 **Language selection:** pick any ISO language code (en, es, fr...) or leave empty for the spoken language.
- 🔗 **Flexible input:** feed video URLs, video IDs, or both, and cap the run with maxItems.

Each row also says which caption track was used (`captionType` is `manual` or `auto-generated`, plus `captionTrackName`) and lists every caption language the video offers.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with YouTube data

**📝 Repurpose video content.**

A content marketer feeds a list of YouTube video URLs and gets full transcripts to turn into blog posts, newsletters, and social media copy.

**🔍 Competitor research.**

A market researcher scrapes transcripts from competitor videos to identify talking points, product mentions, and messaging without watching hours of footage.

**🎙️ Podcast transcription.**

A podcast producer extracts transcripts from video interviews to create searchable show notes and improve SEO.

**📊 NLP dataset building.**

A data scientist collects thousands of transcripts by video ID to train sentiment analysis or topic modeling models.

**♿ Accessibility compliance.**

An accessibility team scrapes transcripts and SRT files to add captions to an existing video library.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key or quotas** | Reads the public caption tracks directly, with no OAuth or daily limits. |
| **Creator captions first** | When a video has a human-made track, you get it instead of the auto-generated one. |
| **Metadata on every row** | Title, channel, duration, views, likes, upload date, tags and caption languages, even on rows without a transcript. |
| **Free error rows** | A video without captions returns a row with the reason and is not billed. |
| **A run that failed says so** | If no video in the run returns a transcript, the run ends as FAILED instead of SUCCEEDED with an empty dataset. |

### Common complaints about transcript scrapers, and what this Actor does

These come from the 1 and 2 star reviews on the most used YouTube transcript Actor in the Apify Store, and from a 3 star question about its pricing.

**"Did not give response to the video."** Every video you send gets a row. If there is no transcript, the `error` field says why: no captions on the video, only auto-generated captions when you turned them off, or the video is private or removed. That row still carries the title, channel and caption languages, and you are not charged for it.

**"Worked very well, but now it stopped."** YouTube changes things, and any scraper can break. This Actor makes a breakage visible. When not a single video in a run returns a transcript, the run ends as FAILED with the reason in the status message, so a scheduled job or an API integration notices at once.

**"Does $7 per 1000 items mean 1000 transcriptions?"** Here, yes. One billed item is one video with its complete transcript, however long the video is. The 58-minute NASA press conference in our tests (1,590 segments, 10,129 words) was one item.

### How it compares

Same videos, same day (September 24, 2026), against the most used transcript Actor in the Store, pintostudio/youtube-transcript-scraper.

| | This Actor | pintostudio/youtube-transcript-scraper |
|---|---|---|
| Captioned test videos returned | 6 of 6 | 6 of 6 |
| Time per run | 4.3 to 11.1 s | 4.4 to 6.0 s |
| Videos per run | Many (URL list, ID list, or both) | One `videoUrl` per run |
| Timestamped segments | Yes | Yes |
| Plain text, word count, SRT | Yes | No, segments only |
| Video metadata and caption languages | Yes, on every row | No |
| Which track when there are several | Creator-made first, `captionType` says which | Not shown |
| Video with no captions | Error row with the reason, not billed | Empty `data: []` row, billed |

### Configure the run

Give the Actor video URLs, video IDs, or both. Set a language if you want a specific one, and cap the run with maxItems. The Input tab lists every parameter. We ran each example below on September 24, 2026; the result is under it.

**1. One video (the default input).**

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc" }],
  "maxItems": 10
}
```

Result: 1 row, 244 segments from the creator-made English track.

**2. Several videos by ID.**

```json
{
  "videoIds": ["iG9CE55wbtY", "arj7oStGLkU", "H14bBuluwB8"]
}
```

Result: 3 rows with 427, 315 and 117 segments, all creator-made English tracks.

**3. A specific language.**

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/watch?v=XUqrvbsTfck" }],
  "language": "es"
}
```

Result: 1 row, 365 segments from the Spanish track.

**4. A short link with an SRT file.**

```json
{
  "startUrls": [{ "url": "https://youtu.be/H14bBuluwB8" }],
  "includeSrt": true
}
```

Result: 1 row with 117 segments and the SRT text in `transcriptSrt`. The SRT is billed as its own event.

**5. Creator-made captions only.**

```json
{
  "videoIds": ["arj7oStGLkU", "BbPeeZLKrT0"],
  "includeAutoGenerated": false
}
```

Result: 1 transcript (315 segments) and 1 unbilled row for BbPeeZLKrT0, which only has auto-generated captions.

### Pricing

Pay per event. You pay for each video that comes back with a transcript. Rows that report an error are free.

| Your Apify plan | Per transcript | Per 1,000 transcripts | SRT export, per video |
|---|---|---|---|
| Free | $0.0099 | $9.90 | $0.0045 |
| Bronze | $0.0096 | $9.60 | $0.00399 |
| Silver | $0.0096 | $9.60 | $0.00351 |
| Gold and above | $0.0096 | $9.60 | $0.003 |

There is no start fee. You pay only for the transcripts delivered. The Pricing tab always shows the live numbers.

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [YouTube Transcript Scraper](https://apify.com/parseforge/youtube-transcript-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to YouTube through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/youtube-transcript-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why does a row have an `error` instead of a transcript?**

The `error` field gives the reason. "No subtitles available for this video" means the video has no caption track at all, so there is nothing to read. "Manual subtitles not available" means you turned off auto-generated captions and the video only has those. "Video not available" means it is private, removed or blocked. "Could not load captions" means YouTube refused several attempts in a row; run the video again. These rows are not billed.

**Why is the transcript in the wrong language?**

Set the language field to the ISO code you want. If the video has no track in that language, you get the spoken language. `availableSubtitleLanguages` and `availableAutoCaptionLanguages` show what the video offers.

**Why is the SRT field empty?**

Set includeSrt to true. With it off, `transcriptSrt` stays empty and you are not charged for it.

**Why did the run stop before processing all my videos?**

Check maxItems. The Actor stops after that many videos. Free-plan runs stop at 10.

**Why did my run end as FAILED?**

No video in the run returned a transcript. The status message lists the first errors. You were not charged for those rows.

### FAQ

| Question | Answer |
|---|---|
| Does this work for auto-generated captions? | Yes. When a video only has auto-generated captions you get those, and `captionType` says `auto-generated`. Turn off includeAutoGenerated to skip them. |
| Which track do I get when there are several? | The track in your chosen language if it exists. Otherwise the spoken language, with the creator-made track ahead of the auto-generated one. |
| Can I get the transcript in a specific language? | Yes, set the language field to an ISO code like en, es, or fr. If the video has no track in that language, you get the spoken language. |
| What is the difference between the JSON transcript and the SRT export? | The JSON transcript is an array of segments with start time, duration, and text. The SRT export is the same text as a subtitle file, in the `transcriptSrt` field. SRT is billed per video and is off by default. |
| How many videos can I scrape in one run? | Up to 1,000,000 with maxItems. The Actor works through 10 videos at a time. |
| Do I need a YouTube API key? | No. There are no API keys, OAuth, or daily quotas. |
| Can I input a YouTube channel or playlist URL? | No, only single videos. To get every video of a channel or playlist, run the [YouTube Scraper](https://apify.com/parseforge/youtube-scraper?fpr=vmoqkp) first and paste its `url` column here. |
| What output formats are supported? | CSV, JSON, Excel, or XML from the Dataset tab or the API. |
| Does it work with age-restricted or private videos? | Private videos do not work, and age-restricted videos may not return a transcript. When no transcript comes back, you get an error row that is not billed. |
| Is the transcript returned as one string or segmented? | Both. `transcriptPlainText` has the full text and `transcript` has the timestamped segments. |
| Can I run this on a schedule? | Yes, you can schedule recurring runs in Apify to collect new transcripts automatically. |

### Next step

Each transcript row names its video and its channel, so you can keep going with the other ParseForge YouTube Actors:

- [YouTube Comments Scraper - Replies and Likes](https://apify.com/parseforge/youtube-comments-scraper?fpr=vmoqkp): put the `url` column in `startUrls` to see how viewers reacted to what was said.
- [YouTube Scraper - Search, Channels and Playlists](https://apify.com/parseforge/youtube-scraper?fpr=vmoqkp): put the `channelUrl` column in `startUrls` to list the channel's other videos, then feed their `url` column back here. It is also the quickest way to get video URLs from a search or a playlist.
- [YouTube Shorts Scraper - 35 Fields Per Short](https://apify.com/parseforge/youtube-shorts-scraper?fpr=vmoqkp): put the `channelUrl` column in `channels` to get the channel's Shorts, then send their `url` column here for the captions. Use the `@handle` links: the Shorts Scraper does not read `/channel/UC...` links yet.
- [YouTube Channel Scraper - Stats and Video List](https://apify.com/parseforge/youtube-channel-scraper?fpr=vmoqkp): put the `channelUrl` column (or `channelId`) in `startUrls` to get the channel's subscribers, total views, video count and latest uploads.

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by YouTube LLC. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Video links in any common form: youtube.com/watch?v=, youtu.be/, /shorts/, /embed/ or /live/. One row per video. Channel and playlist links are not expanded.

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

11-character YouTube video IDs, for example UF8uR6Z6KLc. You can use this list, the URL list, or both.

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

ISO language code such as en, es or fr. If the video has no track in that language, you get the track in the spoken language. Leave empty to get the spoken language.

## `includeAutoGenerated` (type: `boolean`):

Human-made caption tracks are always picked first. When a video only has YouTube's auto-generated captions, turn this off to skip it (you get an unbilled error row) instead of an auto transcript.

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

Adds the transcript in SRT subtitle format in the transcriptSrt field. Billed as a separate event per video. Leave it off to get only the timestamped JSON segments and plain text.

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

Upper limit on videos processed in this run. Leave empty to process every video in the input. Free-plan runs stop at 10.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
    }
  ],
  "includeAutoGenerated": true,
  "includeSrt": false,
  "maxItems": 10
}
```

# 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=UF8uR6Z6KLc"
        }
    ],
    "maxItems": 10
};

// 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=UF8uR6Z6KLc" }],
    "maxItems": 10,
}

# 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(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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/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/qrH7POL2hiiYzH0aa/builds/VioWsXEdtaW06edRr/openapi.json