# YouTube Transcript Scraper: Video to Text, Subtitles & SRT (`quillstone-labs/youtube-transcript-scraper`) Actor

YouTube transcript scraper: turn any YouTube video, Short, playlist or channel into text. Get captions and subtitles as plain text, with timestamps or as SRT, plus title, channel, views and upload date. No login, no API key. Pay per video.

- **URL**: https://apify.com/quillstone-labs/youtube-transcript-scraper.md
- **Developed by:** [Quillstone Labs](https://apify.com/quillstone-labs) (community)
- **Categories:** Videos, Social media, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 transcripts

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 Scraper

Turn YouTube videos into text. This YouTube transcript scraper gets everything that's said in a video, as plain text, line by line with timestamps, or as a ready-made SRT subtitle file. Paste video links, Shorts, playlists or channels, or search YouTube, and each video comes back as one row with its transcript, language, word count, title, channel, views, likes and upload date.

You don't need a YouTube account, a Google API key or a login. Transcripts come from YouTube's own captions, the creator's when they uploaded them and YouTube's automatic ones otherwise, so a video is ready in about a second with no waiting for audio to be processed.

### What you get

| | |
|---|---|
| Transcripts | The spoken words of each video as one block of plain text, in the video's own language |
| Videos, Shorts, playlists, channels | Paste any of them. A playlist or a channel (`@handle`, add `/shorts` for its Shorts) brings in its newest videos |
| YouTube search | Give a search like *sourdough bread recipe* and get the transcripts of the top videos |
| Timestamps and SRT | Optional: the captions line by line with start and end times, plus the same as an `.srt` subtitle file |
| Language choice | Ask for `en`, `es` or any language, and get that caption track when the video has one. Dubbed videos give the original language |
| Video details | Title, channel, upload date, length, views, likes, category, description, tags and thumbnail |
| Plain answers | A one-line summary per video, like *"iPhone Duo Review: First Generation Fun!" by Marques Brownlee, a 29 min 4 s video from 21 Oct 2026 (7,054,421 views): English transcript from the creator's captions, 5,590 words.* |
| Clear "no transcript" rows | Videos without captions, private, age-restricted or deleted videos, and mistyped links each get a row saying why, and cost little or nothing |
| One text file | Every transcript in a single `transcripts.txt`, ready to paste into a document or a chat |
| Excel report | A Videos sheet with transcripts and details side by side, plus Timed captions when timestamps are on |

### Example inputs

The transcript of one video:

```json
{ "videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"] }
```

A batch of videos, links, Shorts and IDs mixed:

```json
{ "videos": ["https://youtu.be/jNQXAC9IVRw", "https://www.youtube.com/shorts/aqz-KE-bpKQ", "9bZkp7q19f0"] }
```

The 50 newest videos of a channel, with timestamps and SRT subtitles:

```json
{ "videos": ["@mkbhd"], "maxVideosPerSource": 50, "includeTimestamps": true }
```

A whole playlist, in English where the videos have English captions:

```json
{ "videos": ["https://www.youtube.com/playlist?list=PLFgquLnL59alCl_2TQvOiD5Vgm1hCaGSI"], "languages": ["en"], "maxVideosPerSource": 200 }
```

The top 10 videos for a search:

```json
{ "searchQueries": ["sourdough bread recipe"], "maxVideosPerSource": 10 }
```

### Ready-made examples

Open one, change the video or channel, and click **Start**:

- [Transcripts of a YouTube channel](https://apify.com/quillstone-labs/youtube-transcript-scraper/examples/youtube-channel-transcripts): the newest videos of any channel as text
- [Transcripts of YouTube search results](https://apify.com/quillstone-labs/youtube-transcript-scraper/examples/youtube-search-transcripts): what the top videos on a topic actually say
- [YouTube video to SRT subtitles](https://apify.com/quillstone-labs/youtube-transcript-scraper/examples/youtube-srt-subtitles): download YouTube subtitles as an `.srt` file

### Who uses it

- **Content creators and marketers** turning videos into blog posts, newsletters and social posts, and studying what top videos in their niche actually say.
- **AI and data teams** feeding video content into chatbots, search indexes and summaries.
- **Researchers and analysts** reading what's said across hundreds of videos on a topic, brand or product.
- **Students and educators** getting the text of lectures and tutorials to read, search and quote.
- **Automated tools and assistants** that are handed a YouTube link and need to know what's in the video, as text.

### How to use it

1. On the **Input** tab, paste your videos under **YouTube videos, playlists or channels**, one per line. Full links, short `youtu.be` links, Shorts, playlists, channels and plain video IDs all work.
2. Optional: add searches under **Search YouTube**, set how many videos to take from each playlist, channel or search, and pick preferred languages.
3. Turn on **Include timestamps and SRT subtitles** if you want the captions line by line with times.
4. Click **Start**.
5. Open the **Output** tab. **Results** shows each video with its transcript. **All transcripts** is one text file with every transcript in order. **Excel report** downloads it all as a spreadsheet.

### Getting your results into Excel, Google Sheets or Word

- **Excel report:** every run saves `transcripts-report.xlsx`, linked as **Excel report** on the Output tab. It opens in Excel, Google Sheets, LibreOffice and Numbers.
- **Word or Google Docs:** open **All transcripts** on the Output tab and paste it in, or copy the Transcript column from the Excel report.
- **Subtitles:** with timestamps on, copy a video's `srt` field into a file ending in `.srt`. Video editors and players open it as subtitles.
- **Other formats:** the **Export** button on the Output tab downloads the results as CSV, JSON, XML or HTML.

### Using it from your own code

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('quillstone-labs/youtube-transcript-scraper').call({
    videos: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].transcript);
```

Or in one request, which waits for the run and returns the rows:

```bash
curl -X POST "https://api.apify.com/v2/acts/quillstone-labs~youtube-transcript-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"videos": ["dQw4w9WgXcQ"]}'
```

In Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("quillstone-labs/youtube-transcript-scraper").call(run_input={"videos": ["dQw4w9WgXcQ"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["transcript"][:200])
```

The input also accepts the field names other YouTube Actors use (`urls`, `startUrls`, `videoUrls`, `videoIds`), so existing code usually works by changing only the Actor name.

### Use it from an AI assistant

Claude, Cursor, VS Code and other assistants that support MCP can run this Actor for you. Add this server to your assistant's MCP settings:

```
https://mcp.apify.com?tools=quillstone-labs/youtube-transcript-scraper
```

The first time it connects, a browser window opens so you can sign in to Apify. Then just ask, for example *"Summarise this video: https://www.youtube.com/watch?v=dQw4w9WgXcQ"* Each result includes a plain-English `explanation` the assistant can pass straight on, and every output field is described, so it knows what each one means. To set up several Actors at once, use Apify's [MCP configurator](https://mcp.apify.com/).

### What a result looks like

```json
{
    "input": "@mkbhd",
    "videoId": "ESABTN4VtrA",
    "url": "https://www.youtube.com/watch?v=ESABTN4VtrA",
    "found": true,
    "hasTranscript": true,
    "transcript": "First-generation devices... are always the most fun to review. And for the past, like, month, everyone I talk to has been asking me...",
    "transcriptLanguage": "en",
    "transcriptSource": "creator",
    "wordCount": 5590,
    "captionLanguages": "en, ja, pt, tr, vi",
    "noTranscriptReason": "",
    "explanation": "\"iPhone Duo Review: First Generation Fun!\" by Marques Brownlee, a 29 min 4 s video from 21 Oct 2026 (7,054,421 views): English transcript from the creator's captions, 5,590 words.",
    "title": "iPhone Duo Review: First Generation Fun!",
    "channel": "Marques Brownlee",
    "channelId": "UCBJycsmduvYEL83R_U4JriQ",
    "channelUrl": "https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ",
    "publishedAt": "2026-10-21T05:00:52-07:00",
    "durationSeconds": 1744,
    "views": 7054421,
    "likes": 148734,
    "category": "Science & Technology",
    "description": "What it's actually like to use the first folding iPhone...",
    "keywords": ["iPhone Duo", "iPhone duo review"],
    "isLive": false,
    "thumbnail": "https://i.ytimg.com/vi/ESABTN4VtrA/sddefault.jpg",
    "source": "channel: Marques Brownlee"
}
```

With **Include timestamps and SRT subtitles** on, each row also has `segments`, a list of `{ "start": 3.16, "end": 4.95, "text": "First-generation devices... are always" }` with times in seconds, and `srt`, the same captions as an SRT subtitle file.

A video that can't be transcribed still gets a row, so you always know what happened to each link:

```json
{
    "input": "https://www.youtube.com/shorts/aqz-KE-bpKQ",
    "found": true,
    "hasTranscript": false,
    "noTranscriptReason": "This video has no captions: the creator added none and YouTube made no automatic ones (common for music, very new, or very short videos).",
    "explanation": "\"Big Buck Bunny 60fps 4K - Official Blender Foundation Short Film\" by Blender, a 10 min 35 s video from 10 Nov 2014 (23,456,373 views): no transcript. This video has no captions..."
}
```

### How much does it cost?

You pay per video, not for run time, and Apify's platform costs are included. A video with a transcript is one charge; a video YouTube has no captions for costs less; links that are deleted, private or not YouTube videos are free. Listing a channel's, playlist's or search's videos is free too: you pay only for the videos read. Timestamps, SRT subtitles, the text file and the Excel report cost nothing extra. Exact prices are on the **Pricing** tab, and they're lower on Apify's paid plans. To cap what a run can cost, set **Max total charge** in the run options before you start.

### FAQ

**How do I get the transcript of a YouTube video?**
Copy the video's link, paste it under **YouTube videos, playlists or channels** and click **Start**. The transcript is in the Results a few seconds later, and in the **All transcripts** text file.

**Can I download YouTube subtitles as SRT?**
Yes. Turn on **Include timestamps and SRT subtitles** and each video gets an `srt` field with its captions as an SRT file, plus `segments` with start and end times in seconds.

**Can I get all the transcripts of a channel or a playlist?**
Yes. Paste the channel (`@handle` or its link) or the playlist link, and set **Videos per playlist, channel or search**. Channels give their newest videos first. Add `/shorts` to a channel link for its Shorts, or `/streams` for its past live streams.

**Does it work with YouTube Shorts?**
Yes. Shorts links (`youtube.com/shorts/...`) work like any other video.

**Can I get podcast transcripts?**
Yes, for podcasts published on YouTube, which most video podcasts are. Paste an episode link, or the podcast's channel or playlist for every episode. Long episodes work the same as short videos.

**Which videos have transcripts?**
Most videos where someone speaks. YouTube captions spoken videos automatically in English and many other languages, and many creators upload their own. Music without lyrics captions, very new videos and very short clips can have none; you'll get a row saying so.

**How accurate are the transcripts?**
They are YouTube's own captions, the same ones viewers turn on with the CC button. Creator captions are usually exact. Automatic ones are generated from the audio, so names and jargon are sometimes misheard, and they often have little punctuation. `transcriptSource` says which kind you got.

**Which languages work?**
Any language a video has captions in. By default you get the language spoken in the video. Set **Preferred caption languages** to get, say, the English track of a video that has one; `captionLanguages` lists every language a video has.

**Can it translate a transcript?**
No. YouTube's automatic translation isn't available without signing in, so you get the caption tracks the video really has. Most AI tools translate a transcript well if you need another language.

**Why does a video say it's unavailable?**
It was deleted or made private, the link has a typo, or it's age-restricted or for channel members only, which YouTube only shows to signed-in viewers. None of these are charged.

**Do I need a YouTube API key or the YouTube Data API?**
No. Nothing to set up: no Google Cloud project, API key or quota.

**How many videos can I run at once?**
As many as you like. A few are read at the same time, so a few hundred videos finish in a couple of minutes.

### More from Quillstone Labs

- **[TikTok Transcript Scraper](https://apify.com/quillstone-labs/tiktok-transcript-scraper)**: the same for TikTok videos, with English translations.
- **[App Store & Google Play Reviews Scraper](https://apify.com/quillstone-labs/app-store-google-play-reviews-scraper)**: reviews from both app stores in one run, with the top complaint words and rating trends.
- **[USPTO Trademark Search & Monitor](https://apify.com/quillstone-labs/uspto-trademark-search)**: is a brand name or slogan already taken in the US, sound-alikes included.
- **[Used Car Search](https://apify.com/quillstone-labs/used-car-search)**: ten used-car sites searched at once, duplicates merged, with a price check.

### Support

Found a bug, or need a field that isn't there? Open an issue on the **Issues** tab and include the input you used. For anything else, like a custom version or a bulk data job, email QuillStoneLabs@yahoo.com.

### Data and fair use

The transcripts and details come from public YouTube videos, as shown to any visitor who isn't signed in. Creators own their content: use transcripts for research, analysis, accessibility and quoting, and don't republish someone else's video content as your own. Output includes channel names, so treat it as personal data where your local law does. This Actor is an independent tool and isn't affiliated with, endorsed by or sponsored by YouTube or Google. YouTube is a trademark of Google LLC.

# Actor input Schema

## `videos` (type: `array`):

One per line. A video link (<code>https://www.youtube.com/watch?v=dQw4w9WgXcQ</code>), a short link (<code>https://youtu.be/...</code>), a Shorts or live link, or just the 11-character video ID. A playlist link or a channel (<code>@handle</code> or its link, add <code>/shorts</code> for its Shorts) brings in its newest videos, up to the limit below. Through the API you can also pass objects like <code>{ "url": "..." }</code>.

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

Optional. Get transcripts of the top videos for a search, like <code>sourdough bread recipe</code>. Each search brings in up to the limit below.

## `maxVideosPerSource` (type: `integer`):

How many videos to take from each playlist, channel or search, newest first for channels. Listing them is free; you only pay for the videos read.

## `languages` (type: `array`):

Optional, like <code>en</code> or <code>es</code>. When a video has captions in one of these languages, that track is used, the creator's own before YouTube's automatic ones. Leave empty to get the language spoken in the video.

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

Also return the captions line by line with start and end times in seconds, plus the same as a ready-made SRT subtitle file in the <code>srt</code> field. Off by default to keep results short.

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

YouTube asks many server addresses to prove they're not a bot. Apify Proxy switches address when that happens.

## `residentialFallback` (type: `boolean`):

When YouTube keeps refusing a video on the normal connection, try it twice more on Apify's residential proxy. No extra charge to you.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ],
  "maxVideosPerSource": 20,
  "includeTimestamps": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true
}
```

# Actor output Schema

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

No description

## `text` (type: `string`):

No description

## `report` (type: `string`):

No description

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

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

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

```

## MCP server setup

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