# YouTube Transcript Scraper - Captions & Subtitles (`kaleidoscopelabs/youtube-transcript-scraper`) Actor

YouTube transcript API and YouTube to text: videos, channels and playlists as timestamped caption lines, the full transcript, and SRT or WebVTT subtitles to download at no extra charge. 220 languages by name, or all a video has. Title, channel, views and length included. No captions, no charge.

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

## Pricing

from $3.00 / 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

### What can YouTube Transcript Scraper do?

**Get the transcripts of YouTube videos, channels and playlists: every caption line with its start and duration, the whole text, in the languages you choose, as JSON, CSV, Excel, SRT or WebVTT.**

- 📝 **Transcripts:** every line of a video's captions with when it starts and how long it shows, and the whole text in one field, ready for a summary, a search index or an AI pipeline.
- 📺 **Channels and playlists:** a channel's newest videos or a playlist in its order, up to a count you set, and only those published since a day or a span such as 30 days, each with its publish date and category.
- 🌍 **Languages:** the language spoken in each video by default; or the languages you choose from a list of 220; or every language a video has, one record each.
- 🎬 **Subtitle files:** each transcript as SRT or WebVTT text in its record, ready to save as a subtitle file.
- ✅ **Videos without captions are free:** a video that has no captions, or not in your language, is stored with the reason and the languages it has, and is not charged.

Run it from Apify Console, through the API, on a schedule, or from an AI agent. The prefilled input reads one NASA video and NASA's 10 newest videos (on 2026-10-28, 10 transcripts in 20 seconds: the video was among the newest), so you can see the output before a larger run.

| You want | Use | What it costs |
|---|---|---|
| A video's transcript as text | Its link or ID | $0.003 |
| A channel's or playlist's talks as a dataset | The channel's or playlist's link, a count, a date | $3.00 per 1,000 transcripts |
| Only the videos published since yesterday | Published since: 1 day, on a daily schedule | $0.003 per new video with captions |
| Subtitles in several languages | Languages, or Every language a video has, and Subtitle files | $0.003 per video and language |
| To know which languages a video has | Any input: every record lists them | Free when the video has none in your language |

### What data do you get from a YouTube video?

| Field | What it holds |
|---|---|
| `videoId`, `url`, `title`, `description` | The video's ID, page, title and description |
| `channelName`, `channelId`, `channelUrl` | The channel that published it |
| `durationSeconds`, `viewCount`, `isLive` | Its length, its views when read, and whether it is a stream live now |
| `publishedAt`, `category` | Its publish date with its time zone, and YouTube's category: for videos read from a channel or a playlist |
| `language`, `languageName`, `trackKind` | The transcript's language, its name as YouTube gives it, and whether the captions are uploaded (written by the channel) or automatic (YouTube's) |
| `requestedLanguage` | The language you asked for this record, when you chose languages |
| `segments` | The caption lines in order, each with `start` and `duration` in seconds and its `text` |
| `text` | The whole transcript: the lines joined by spaces |
| `srt`, `vtt` | The transcript as an SRT or WebVTT file, when you ask for one |
| `availableLanguages` | Every caption track the video has: its code, name and kind |
| `availableLanguageNames` | The same tracks' names as one text, joined by commas, for a spreadsheet |
| `unavailableReason` | YouTube's own reason, for a video it does not play |
| `source`, `sourceType` | The line of your input that led to the video, and whether it was a video, a channel or a playlist |
| `position` | A listed video's place in its channel or playlist, from 1 (a channel's newest, a playlist's first). Records come as they are read: sort by it for the list's order |
| `missing` | What the record lacks, and why |

Measured on 2026-10-27: of the 1,530 newest videos of nine institutions' channels (NASA, MIT OpenCourseWare, Ahrefs and others), 1,482 had captions and 48 had none; every listed video had its publish date.

### How to use YouTube Transcript Scraper

1. Create a free Apify account and open YouTube Transcript Scraper in Apify Console.
2. In **Videos, channels or playlists**, enter what to read, one per line: a video's link or ID, a channel's link (such as https://www.youtube.com/@NASA) or a playlist's link.
3. Choose **Languages** if you want others than each video's own, or turn on **Every language a video has**; add **Subtitle files** for SRT or WebVTT.
4. For channels and playlists, set **Videos per channel or playlist** and, if you want, **Published since**.
5. Click **Start**, then download the transcripts as JSON, CSV, Excel or HTML, or read them through the API. For CSV or Excel, choose the **Transcripts** view: it has the whole transcript in one cell, while all fields give each caption line columns of its own.

### How much does it cost to get YouTube transcripts?

YouTube Transcript Scraper is priced per event, with no usage fees on top:

| Event | Price | When |
|---|---|---|
| Transcript | $3.00 per 1,000 | each record stored with its transcript: one per video and language |

A video without captions, without the language you asked for, private, removed or live now is stored with the reason and is not charged. The platform also charges $0.00005 when a run starts.

| Transcripts stored | Cost |
|---|---|
| 1 | $0.003 |
| 100 | $0.30 |
| 1,000 | $3.00 |
| 10,000 | $30.00 |

- **A channel's last six months:** 20 videos of Ahrefs' channel published since six months before 2026-10-28 gave 20 transcripts: $0.06.
- **A video in four languages with SRT files:** 4 transcripts, $0.012. Every language of the same NASA video: 20 transcripts, $0.06.
- **A daily run for one channel's new videos:** DW News' channel, published since 1 day: 8 videos on 2026-10-28, $0.024; a day without new videos costs only the run's start.

Apify's free plan credit of $5 a month covers about 1,600 transcripts. Set a maximum total charge in the run options to cap a run: the Actor stops before it.

### Input recipes

Each recipe is a complete input: paste it into the JSON tab of the input form, or send it through the API. Fields left out take their defaults. The results are from runs on 2026-10-28.

**A video's transcript** (one NASA video: 1 transcript, in 6 seconds):

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

**A channel's last six months, for research** (Ahrefs' channel: 20 transcripts, 7 uploaded and 13 automatic, each with its publish date, in 32 seconds):

```json
{
  "urls": ["https://www.youtube.com/@AhrefsCom"],
  "maxVideos": 20,
  "dateFrom": "6 months"
}
```

**Only new videos, every day** (DW News' channel; schedule it daily. On 2026-10-28, 1 day gave 8 videos, each with its publish date and automatic captions, in 89 seconds):

```json
{
  "urls": ["https://www.youtube.com/@dwnews"],
  "maxVideos": 0,
  "dateFrom": "1 day"
}
```

**Lectures for a knowledge base** (MIT OpenCourseWare's 18.06 Linear Algebra playlist, its first 5: a 7-minute interview with the lecturer, then lectures of 40 to 48 minutes, all with uploaded captions, in 9 seconds):

```json
{
  "urls": ["https://www.youtube.com/playlist?list=PLE7DDD91010BC51F8"],
  "maxVideos": 5
}
```

**Subtitles in four languages** (the NASA video in Spanish, French, German and Japanese, with SRT: 4 transcripts, in 4 seconds):

```json
{
  "urls": ["https://www.youtube.com/watch?v=Zezt6EsG9WE"],
  "languages": ["es", "fr", "de", "ja"],
  "subtitleFormats": ["srt"]
}
```

**Every language a video has** (the same video: 20 transcripts, 1 uploaded and 19 automatic, with WebVTT, in 5 seconds):

```json
{
  "urls": ["https://www.youtube.com/watch?v=Zezt6EsG9WE"],
  "allLanguages": true,
  "subtitleFormats": ["vtt"]
}
```

API and agent calls that leave `maxVideos` out get up to 50 videos per channel or playlist; 0 reads every video. A call that leaves `urls` out reads the prefilled NASA video and NASA's channel, and is charged as any run. Published since takes a date such as 2026-10-01 or a span back from today such as 30 days.

| You see | Why, and what to do |
|---|---|
| A record with no `text` | The video has no captions, or none in the language you asked for: `missing` says which, and `availableLanguages` lists what it has. Not charged |
| Fewer records than videos in the channel | Videos per channel or playlist (50 by default) and Published since bound it; set 0 for every video |
| `trackKind` is automatic | The channel uploaded no captions in that language: these are YouTube's automatic captions |
| No records, and the input's own message, such as "Enter at least one video, channel or playlist." | Nothing was read or charged: correct the input as it says and run it again (RUN_SUMMARY's `inputError` names the kind, for a program) |

### Output example

A transcript from the prefilled input (shortened: the description and two of its lines, two of its 21 caption tracks). The video was given by its link, so its publish date is not read, and `missing` says so; a video read from a channel or a playlist also has `publishedAt` and `category`:

```json
{
  "videoId": "Zezt6EsG9WE",
  "url": "https://www.youtube.com/watch?v=Zezt6EsG9WE",
  "title": "NASA Moon Base: Rovers and Lunar Terrain Vehicles (October 2026 Update)",
  "channelName": "NASA",
  "channelId": "UCLA_DiR1FfKNvjuUpBHmylQ",
  "channelUrl": "https://www.youtube.com/channel/UCLA_DiR1FfKNvjuUpBHmylQ",
  "durationSeconds": 557,
  "viewCount": 935631,
  "description": "There's a lot of ground to cover when you're building a Moon Base.",
  "isLive": false,
  "language": "en",
  "languageName": "English",
  "trackKind": "uploaded",
  "segments": [
    {
      "start": 2.135,
      "duration": 0.934,
      "text": "Think about"
    },
    {
      "start": 3.069,
      "duration": 3.337,
      "text": "hundreds of square miles where we have different assets."
    }
  ],
  "text": "Think about hundreds of square miles where we have different assets. Multiple landers in different places of the Moon...",
  "availableLanguages": [
    {
      "code": "en",
      "name": "English",
      "kind": "uploaded"
    },
    {
      "code": "de",
      "name": "German (auto-generated)",
      "kind": "automatic"
    }
  ],
  "availableLanguageNames": "English, German (auto-generated)",
  "source": "https://www.youtube.com/watch?v=Zezt6EsG9WE",
  "sourceType": "video",
  "missing": [
    {
      "group": "publishedAt",
      "reason": "notRead"
    }
  ]
}
```

With Subtitle files, the record also holds `srt` or `vtt`. The start of the German SRT of the same video, from the "Subtitles in four languages" recipe:

```text
1
00:00:02,139 --> 00:00:05,338
Stellen Sie sich Hunderte von Quadratkilometern vor, auf denen wir
```

The run's default key-value store also holds **RUN_SUMMARY**: what the run stored, the records without a transcript and why, what could not be read, how the run ended (`ended`: finished, timedOut, aborted, maximumCost and the like), whether it did all it was asked (`complete`: false when it ended early or something could not be read; videos without captions or a date leave it true), and a Ref to quote if you report a problem. **RUN_PROGRESS** lists, by their IDs, the videos and channels or playlists the run could not read: written when the platform moves the run and at its end, so that a run moved or resurrected counts them once.

The dataset has two views: Transcripts (title, place in the list, channel, publish date, length, language, the kind of captions, the text, the link) and Videos (title, place in the list, channel, publish date, length, views, the languages by name, what is missing, the link).

### YouTube subtitles: SRT and WebVTT

Turn on **Subtitle files** to get each transcript as an SRT or WebVTT file in its record, with one cue per caption line. YouTube's automatic captions show each line until two lines later; in the files, each cue ends when the next begins, so no two show at once. Save the `srt` or `vtt` field as a .srt or .vtt file to load it in a video player or an editor. The files cost nothing on top of the transcript.

### YouTube to text: plain text for AI and search

Every record holds the whole transcript in `text`, the caption lines joined by spaces, next to the timed `segments`. Feed `text` to a summary, a search index or a retrieval pipeline, and keep `segments` to link an answer back to the moment in the video (`start` is in seconds: add `&t=` and the whole seconds to the video's `url`).

### Integrations and API

- **Make, Zapier, n8n:** start a run with a video or a channel and get the transcripts when it finishes.
- **Google Sheets, webhooks, the Apify API and clients** for JavaScript and Python.
- **AI agents:** through Apify's MCP server, an agent can call the Actor as a tool.

Run a recipe and get its records in one call (with your Apify API key in the APIFY_TOKEN variable):

```bash
curl -X POST "https://api.apify.com/v2/acts/kaleidoscopelabs~youtube-transcript-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.youtube.com/watch?v=Zezt6EsG9WE"]}'
```

### Building on this Actor

- **Output stability:** fields are added, never renamed or removed without a new major version; every change is in the changelog with its date, and a breaking one is announced here and in the changelog before the build.
- **What a run's end means:** every video read has a record, with `missing` naming what it lacks; a video or a channel or playlist that could not be read is counted in the run's last message and named by its ID in RUN_PROGRESS. A run that stores nothing because YouTube did not answer fails instead of succeeding empty. An input the Actor cannot read (no line it can read as a video, channel or playlist, a value it does not take) ends the run at once, with the reason as its last message, nothing read and nothing charged.
- **Cost per call:** one event, $3.00 per 1,000 transcripts (one per video and language returned); a record without a transcript is never charged; the run stops before your maximum total charge.
- **Notice:** price changes follow Apify's 14-day notice; retiring the Actor is announced here first.

| `missing` | Meaning |
|---|---|
| `transcript`: noCaptions | the video has no captions |
| `transcript`: languageNotAvailable | not in the language asked for; `availableLanguages` lists what it has |
| `transcript`: notGiven | the captions could not be read |
| `transcript`: live | a stream live now |
| `video` and `transcript`: unavailable, private, ageRestricted, membersOnly, upcoming, unplayable | YouTube does not play the video; `unavailableReason` gives its reason |
| `publishedAt`: notRead | a video given by its link or ID: no publish date is read |
| `publishedAt`: notGiven | a listed video YouTube gave no date for; Published since was not applied to it |
| `srt` or `vtt`: tooLarge | a subtitle file left out of a record too large to store |

### For AI agents

Connect an MCP client (Claude, Cursor and others) to `https://mcp.apify.com?tools=kaleidoscopelabs/youtube-transcript-scraper` with your Apify API key, then ask, for example:

- "Summarise the transcript of https://www.youtube.com/watch?v=Zezt6EsG9WE."

- "Get the transcripts of the videos DW News published yesterday."

- **Minimal input:** `{"urls": ["https://www.youtube.com/watch?v=Zezt6EsG9WE"]}`: one record, in the language spoken in the video.

- **Fields to read:** `text` for the transcript, `title`, `channelName`, `durationSeconds` and `publishedAt` for context, `segments` for timestamps, `language` and `trackKind` for which captions they are.

- **What to know:**
  - When you are not sure which language a video has, leave Languages empty: each video's own language is read, and `availableLanguages` lists the others.
  - A record without `text` says why in `missing` (no captions, or not in the language asked for) and is not charged; it is never an empty result that looks like a transcript.
  - Each language is a record of its own, with `requestedLanguage` set when you chose languages.
  - An input the Actor cannot read (no line, no line it can read as a video, channel or playlist, a setting it does not take) ends the run SUCCEEDED with nothing read or charged and an empty dataset: the key-value record RUN_SUMMARY then has `inputError` (noQuery, noReadableLine or invalidSetting) and `message`, with no Ref and no times, as nothing ran; otherwise `inputError` is null. Check it before reading an empty dataset as "no transcripts".
  - Every record carries the input line it came from in `source`, so the records of a run with many lines split back by line. A video that two lines name is stored once, under the line that reached it first.

### Tips

- **Try it cheap:** the prefilled input reads about 10 videos in half a minute; raise the count once the output looks right.
- **Each video's own language is the default:** choose languages only when you need others; each language returned is one transcript.
- **Uploaded captions come first:** for each language the channel's own captions are taken before YouTube's automatic ones, and `trackKind` says which you got.
- **English means any English:** en takes any English track (en, en-GB, en-US); a regional form such as pt-BR takes that form first, then the bare language.
- **A daily schedule with Published since 1 day** reads the videos published yesterday and today, so a video appears in two days' runs: keep one record per `videoId` when you join the runs.

### FAQ

#### Is it legal to get YouTube transcripts?

The Actor reads captions that YouTube shows to every visitor of a public video, at a modest pace. YouTube's terms of service govern how its site is used, and how you use the transcripts is your responsibility: check the laws and terms that apply to you and the purpose you use them for.

#### Does it collect personal data?

The transcripts are what the channels and YouTube published, and they can contain names or other personal data said aloud in a video. The Actor reads no comments and no data about viewers. If you store or process transcripts that name people, you need a lawful basis for it under the GDPR or the laws that apply to you.

#### Why does a video have no transcript?

The video has no captions, or none in the language you asked for. Its record says which in `missing`, lists the languages it has in `availableLanguages`, and is not charged. A private, removed, age-restricted or members-only video, or one not started yet, says so too, with YouTube's reason; a stream live now has no transcript until it ends.

#### Are automatic captions a translation?

No. The Actor reads the caption tracks a video has: those the channel uploaded and YouTube's automatic ones, including the automatic captions of a video YouTube dubbed into other languages. `trackKind` says which a record holds. It does not translate captions itself.

#### Is there an official YouTube transcript API?

YouTube's Data API gives a video's captions only to someone with permission to edit that video; it does not give the captions of other channels' videos. This Actor reads what YouTube shows on a public video's page.

#### Can it read every video of a large channel?

Yes: set Videos per channel or playlist to 0. A channel's uploads are read newest first, a playlist in its order to its end (measured on 2026-10-27 with channels of up to 170 videos each). If a channel's first 20 videos have no transcript in the languages you asked for, the rest of it is not read, and the log says so.

#### Something went wrong: what should I check?

Check that each line is a video's link or ID, a channel's link or a playlist's link. The run's last message says how it ended and how many videos could not be read; RUN_SUMMARY says the same, with the Ref. If a run keeps failing, report it with the Ref from its last message.

### Limits

- **Captions only:** the Actor reads captions; it does not transcribe a video's audio. A video without captions has no transcript.
- **No translation:** only the caption tracks a video has; a language it lacks is said, not translated.
- **Channels:** a channel's uploaded videos (its Videos tab), not its Shorts or live streams tabs; a Short or a past stream given by its link is read.
- **Publish dates** come with videos read from a channel or a playlist; a video given by its link or ID has none (`missing` says notRead), and Published since applies to channels and playlists only. A listed video whose date YouTube does not give is kept, its record saying so (`missing`: publishedAt notGiven): Published since could not be applied to it, and the run's last lines count such videos.
- **A playlist with Published since and a count:** a playlist is not in date order, so its first videos up to the count are read and the older ones among them left out: a playlist can give fewer videos than the count while later ones are in the period. Set the count to 0 for every video in the period.
- **Very long videos with subtitle files:** a record over about 9 MB (a video of about 10 hours with both files) leaves out its subtitle files and says so; its transcript stays.

### Support and feedback

Open an issue on the Actor's Issues tab: we answer within 24 hours. If the Actor helps you, a review and a bookmark help others find it.

*YouTube Transcript Scraper is an independent tool, not affiliated with, endorsed by or sponsored by Google LLC. YouTube is a trademark of Google LLC.*

# Changelog

This Actor's version history is a separate document: https://apify.com/kaleidoscopelabs/youtube-transcript-scraper/changelog.md

# Actor input Schema

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

What to read, one per line: a video's link (watch, youtu.be, Shorts, embed, live) or its 11-character ID; a channel's link (https://www.youtube.com/@NASA, /channel/…, /c/…, /user/…), for its uploaded videos, newest first; or a playlist's link (with list=). A watch link inside a playlist reads that video. A line that is none of these is skipped and said in the log.

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

The transcript's languages, a record per video and language: uploaded captions first, then automatic ones; English takes any English track. Leave it empty for each video's own language (the one spoken in it). Each language returned is one transcript.

## `allLanguages` (type: `boolean`):

A record for each language the video has captions in, each one transcript: a dubbed video can have a dozen. Languages is ignored when this is on.

## `subtitleFormats` (type: `array`):

Also give each transcript as SRT or WebVTT text in the record (srt, vtt), ready to save as a subtitle file. The plain text and the timed lines are always there.

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

How many videos each channel or playlist contributes: a channel's newest first, a playlist's in its order (with Published since, counted before the older ones are left out); 0 reads every video. Videos given by link or ID are always read.

## `dateFrom` (type: `string`):

Only a channel's or playlist's videos published on or after this day: a date, or a span back from today such as 30 days. A channel's list stops at its first older video. Videos given by link or ID are read whatever their date.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=Zezt6EsG9WE",
    "https://www.youtube.com/@NASA"
  ],
  "languages": [],
  "allLanguages": false,
  "subtitleFormats": [],
  "maxVideos": 10
}
```

# Actor output Schema

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

One record per video and language in the run's default dataset: the transcript's lines and text, the video's details, and what the record lacks.

## `summary` (type: `string`):

What the run did: the transcripts stored, the records without one and why, what could not be read, and the Ref to quote in an issue.

## `progress` (type: `string`):

The videos and channels or playlists the run could not read, by their IDs: written when the platform moves the run and at its end, so a run moved or resurrected counts them once.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.youtube.com/watch?v=Zezt6EsG9WE",
        "https://www.youtube.com/@NASA"
    ],
    "languages": [],
    "subtitleFormats": [],
    "maxVideos": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaleidoscopelabs/youtube-transcript-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": [
        "https://www.youtube.com/watch?v=Zezt6EsG9WE",
        "https://www.youtube.com/@NASA",
    ],
    "languages": [],
    "subtitleFormats": [],
    "maxVideos": 10,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.youtube.com/watch?v=Zezt6EsG9WE",
    "https://www.youtube.com/@NASA"
  ],
  "languages": [],
  "subtitleFormats": [],
  "maxVideos": 10
}' |
apify call kaleidoscopelabs/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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