# YouTube Transcript & Subtitles Scraper | $0.65 per 1,000 (`m_ctim/youtube-transcript-scraper`) Actor

YouTube transcripts for $0.65 per 1,000: videos, Shorts, whole channels, playlists or search results. Clean text plus timestamps or SRT, in any caption language, with title, channel, views and length included free. Schedule it on channels to get only new videos.

- **URL**: https://apify.com/m_ctim/youtube-transcript-scraper.md
- **Developed by:** [Timothy Kelvin](https://apify.com/m_ctim) (community)
- **Categories:** Videos, AI, Social media
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.65 / 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.

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 & Subtitles Scraper | $0.65 per 1,000

Get the transcript of any YouTube video, Short, whole channel, playlist or search, as clean text with timestamps, for **$0.65 per 1,000 transcripts**. Each row also carries the video's title, channel, views, length, keywords and description at no extra cost.

Built for feeding transcripts to AI tools (summaries, RAG, chatbots), repurposing videos into posts and articles, research across many videos, and keeping up with channels.

### What you get

- **Any source, mixed in one run:** video links (watch, youtu.be, Shorts, live, embed), channels (@handle, link or ID; newest first; videos, Shorts, live streams or all), playlists, and YouTube searches.
- **Clean text plus timestamps:** `text` is the whole transcript as one block; `segments` has each caption line with its start time and duration in seconds. Turn on `includeSrt` for a ready-to-save SRT subtitle file.
- **Any caption language:** say which languages you want, in order (`"en"`, or `"es, en"`). Captions written by the uploader are used before YouTube's automatic ones (you can flip that). If a video has none in your language, you get the language it does have, unless you switch that off. Every row lists all the languages the video has.
- **Video details included:** title, channel name and link, views, length in seconds, live or not, keywords, description and thumbnail.
- **Only new videos:** turn on `onlyNew` and schedule the run on your channels. Each run returns transcripts of new uploads only, and skipped videos cost nothing.
- **You only pay for transcripts.** A video without captions, a private or deleted video, or a link that isn't YouTube gets a free row saying why.

### Input examples

A few videos:

```json
{
    "videos": [
        "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
        "https://youtu.be/jNQXAC9IVRw"
    ]
}
```

The 50 newest videos of two channels, in Spanish when available:

```json
{
    "channels": ["@mkbhd", "https://www.youtube.com/@veritasium"],
    "maxVideosPerChannel": 50,
    "language": "es, en"
}
```

A daily channel monitor (schedule it; each run returns only new uploads):

```json
{
    "channels": ["@lexfridman"],
    "channelContent": "videos",
    "maxVideosPerChannel": 5,
    "onlyNew": true,
    "seenListName": "podcast-monitor"
}
```

The top 20 results of a search, with SRT files:

```json
{
    "searchQueries": ["how to start a podcast"],
    "maxVideosPerSearch": 20,
    "includeSrt": true
}
```

### Output

One row per video. A real row (the transcript and segments are cut short here):

```json
{
    "rowType": "transcript",
    "videoId": "UF8uR6Z6KLc",
    "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
    "found": true,
    "title": "Steve Jobs' 2005 Stanford Commencement Address",
    "channelName": "Stanford",
    "channelId": "UC-EnprmCZ3OXyAoG7vjVNCA",
    "channelUrl": "https://www.youtube.com/channel/UC-EnprmCZ3OXyAoG7vjVNCA",
    "durationSeconds": 904,
    "viewCount": 49431582,
    "isLiveContent": false,
    "keywords": ["apple", "graduation", "education", "NeXT"],
    "description": "Drawing from some of the most pivotal points in his life, Steve Jobs, chief executive officer and co-founder of Apple Co...",
    "thumbnailUrl": "https://i.ytimg.com/vi/UF8uR6Z6KLc/hqdefault.jpg",
    "language": "en",
    "languageName": "English - English",
    "isAutoGenerated": false,
    "languageMatched": true,
    "availableLanguages": [
        { "code": "ar", "name": "Arabic", "autoGenerated": false },
        { "code": "en", "name": "English (auto-generated)", "autoGenerated": true },
        { "code": "en", "name": "English - English", "autoGenerated": false },
        { "code": "it", "name": "Italian", "autoGenerated": false }
    ],
    "wordCount": 2298,
    "text": "This program is brought to you by Stanford University. Please visit us at stanford.edu ...",
    "segments": [
        { "start": 7.47, "duration": 2.899, "text": "This program is brought to you by Stanford University." },
        { "start": 10.47, "duration": 3.973, "text": "Please visit us at stanford.edu" }
    ],
    "source": "video",
    "sourceInput": "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
    "scrapedAt": "2026-11-15T01:52:36.348Z"
}
```

A video with no transcript comes back free, with `found: false` and a `reason`, for example "This video has no captions on YouTube (none written and none generated), so there is no transcript."

| Field | What it is |
|---|---|
| `rowType` | `transcript` for every video; `error` for an input that couldn't be used; `note` when a run has nothing to return |
| `found` | `true` when the row has a transcript (charged), `false` when not (free, see `reason`) |
| `text` | The whole transcript as one block of text |
| `segments` | Caption lines with `start` and `duration` in seconds (when `includeTimestamps` is on, the default) |
| `srt` | The captions as an SRT file (when `includeSrt` is on) |
| `language`, `languageName`, `isAutoGenerated` | The caption track used |
| `languageMatched` | `false` when no track was in your language and the video's own language was used instead |
| `availableLanguages` | Every caption track the video has |
| `source`, `sourceInput` | Where the video came from: `video`, `channel`, `playlist` or `search`, and the entry you gave |

The run's totals are saved in the key-value store record `SUMMARY`.

### Pricing

Pay per result, no subscription:

| | Price |
|---|---|
| Each transcript returned | **$0.00065** ($0.65 per 1,000) |
| Each run start | $0.0001 |
| Videos without captions, errors, skipped videos | free |

1,000 transcripts in one run cost $0.6501. Apify's free plan includes $5 of usage a month, which covers about 7,500 transcripts. You can also set a maximum cost per run in the run options.

### Good to know

- **The transcript is YouTube's captions:** the uploader's own or YouTube's automatic ones. A video with no captions at all has no transcript here (no speech-to-text yet).
- **Never signs in:** age-restricted, private and members-only videos can't be read, and you get a free row saying so.
- **YouTube's machine translation isn't offered:** YouTube refuses translated captions to apps like this one (checked November 2026). You get any language the video has captions in.
- **Upload dates aren't included yet:** YouTube's app answer used here doesn't carry them.
- **Speed:** 8 videos at a time; in testing, 23 videos plus a channel, a playlist and a search took about 30 seconds. A run stops starting new videos 30 seconds before its time limit, so it ends cleanly.

### Feedback

Missing a field or found a video that should have worked? Open an issue on the Issues tab with the video link and I'll look at it.

# Actor input Schema

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

YouTube video links or 11-character IDs: watch links, youtu.be, Shorts, live and embed links all work. Leave everything empty to run the example videos.

## `channels` (type: `array`):

Channel links, @handles or channel IDs (UC...). The newest videos of each channel are transcribed, newest first.

## `channelContent` (type: `string`):

Regular videos, Shorts, past live streams, or all of them.

## `maxVideosPerChannel` (type: `integer`):

How many of each channel's newest uploads to transcribe (1 to 5,000).

## `playlists` (type: `array`):

Playlist links (with list=...) or playlist IDs.

## `maxVideosPerPlaylist` (type: `integer`):

How many videos of each playlist to transcribe, in playlist order (1 to 5,000).

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

Search terms, as you'd type them on YouTube. The top video results are transcribed.

## `maxVideosPerSearch` (type: `integer`):

How many of the top results of each search to transcribe (1 to 500).

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

Language code(s) to prefer, in order, e.g. "en" or "es, en". Regional versions match too ("en" matches en-US and en-GB).

## `fallbackToAnyLanguage` (type: `boolean`):

When a video has no captions in your language, return the captions it does have (usually its spoken language). Off: such videos get a free row listing the languages available.

## `preferManualCaptions` (type: `boolean`):

When a video has both, use the uploader's own captions over YouTube's automatic ones. Off: use the automatic ones (closer to what was said, word for word).

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

Add a segments list: each caption line with its start time and duration in seconds.

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

Add the captions as SRT text, ready to save as a .srt file.

## `onlyNew` (type: `boolean`):

Skip videos that earlier runs with this option already returned. Schedule it on channels to get transcripts of new uploads only. Skipped videos aren't charged.

## `seenListName` (type: `string`):

Give each monitor its own list (3 to 63 lowercase letters, digits and hyphens), e.g. "ai-channels". Empty: one shared list.

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

A cap on how many videos one run transcribes (1 to 20,000), so a big channel or playlist can't run longer than you meant.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
    "https://youtu.be/jNQXAC9IVRw"
  ],
  "channels": [],
  "channelContent": "videos",
  "maxVideosPerChannel": 10,
  "playlists": [],
  "maxVideosPerPlaylist": 100,
  "searchQueries": [],
  "maxVideosPerSearch": 20,
  "language": "en",
  "fallbackToAnyLanguage": true,
  "preferManualCaptions": true,
  "includeTimestamps": true,
  "includeSrt": false,
  "onlyNew": false,
  "maxVideos": 1000
}
```

# Actor output Schema

## `results` (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=UF8uR6Z6KLc",
        "https://youtu.be/jNQXAC9IVRw"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("m_ctim/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=UF8uR6Z6KLc",
        "https://youtu.be/jNQXAC9IVRw",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("m_ctim/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=UF8uR6Z6KLc",
    "https://youtu.be/jNQXAC9IVRw"
  ]
}' |
apify call m_ctim/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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