# YouTube Transcript & Subtitles Scraper API (`data_minds/youtube-transcript-subtitles-scraper-api`) Actor

Get full YouTube transcripts with timestamps and chapters, plus SRT, VTT and TXT subtitle files. Works for videos, Shorts, playlists, channels and search phrases. Language choice, no login or cookies. Bulk input, auto proxy. Export JSON, CSV or Excel.

- **URL**: https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api.md
- **Developed by:** [Data Minds](https://apify.com/data_minds) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### What is YouTube Transcript & Subtitles Scraper API?

**YouTube Transcript & Subtitles Scraper API** is a YouTube subtitles scraper that turns video, Shorts, playlist and channel links, @handles and search phrases into transcripts, chapters and ready-made SRT, VTT or TXT subtitle files. Paste your links, pick a language, and get one dataset row per video with the full timestamped transcript, plain text and video details. Pay per saved transcript, from $0.002 on the Gold plan. [🚀 Try it free](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api)

Use it for bulk YouTube transcript download jobs and to:

- 🤖 **Build AI training data from YouTube transcripts:** collect clean text for LLM training data, with language, caption type and word count for every video.
- 🔎 **Feed a RAG knowledge base:** turn whole channels and playlists into transcript text for a vector store or an LLM prompt.
- ♿ **Create subtitle files for accessibility:** download SRT, WebVTT or plain text subtitle files for each video as accessibility captions.
- 📊 **Research a channel's content:** read views, likes, comments, tags and chapters next to each transcript for keyword analysis and competitor video analysis.
- 📝 **Repurpose videos into blog posts and study notes:** get the whole transcript as one block of text, or chapter by chapter.
- ⏰ **Monitor new videos on a schedule:** run it on a schedule so your transcript data stays fresh.

It runs on the Apify platform, so you also get the Apify API, scheduling, webhooks, integrations and dataset exports in JSON, CSV, Excel, XML and HTML. It reads transcripts from public [YouTube](https://www.youtube.com) videos that have a caption track.

#### What can YouTube Transcript & Subtitles Scraper API do?

- 🔗 **Mix sources in one field:** videos, Shorts, playlists, channels (link, @handle or channel ID) and search phrases.
- 🌍 **Pick caption languages in priority order:** choose from 31 language options; if none matches, the closest track is returned and `language_matched` says so.
- 🧾 **Prefer creator captions:** manual captions are chosen over auto-generated YouTube closed captions, and `is_generated` tells you which one you got.
- 💾 **Get subtitle files:** SRT, WebVTT and plain text added to every video row.
- 📚 **Read chapters with their own text:** each chapter carries the transcript that falls inside it.
- 📈 **Get reading statistics:** word count, reading time and speaking rate per video.
- 🕒 **Get a YouTube transcript with timestamps:** every segment has a `start` and a `duration`, and the plain text is saved too.
- ⚡ **See results while the run is going:** every row is saved as soon as it is ready, and failed videos are listed with a reason.

#### Which YouTube transcript Actor should I use?

This Actor is built around subtitle files, chapters with their own text and eight ready-made output tables. If you mainly need a choice of caption languages or control over Shorts found in channels and playlists, the sibling [YouTube Transcript Scraper](https://apify.com/data_minds/youtube-transcript-scraper) is the better match. See the table of related Actors below.

### What data can YouTube Transcript & Subtitles Scraper API extract?

Each video becomes one row. The table lists every field.

| Group | Field | What it holds |
|---|---|---|
| 🎬 Video | `url`, `video_id`, `title` | Watch link, 11-character video ID and title |
| 📺 Channel | `channel_name`, `channel_id`, `channel_url`, `channel_subscribers` | Channel name, ID, link and approximate subscriber count |
| 👁 Engagement | `view_count`, `like_count`, `comment_count` | View, like and approximate comment counts |
| 🗓 Dates | `upload_date`, `published_at` | Upload date (YYYY-MM-DD) and publish timestamp |
| 🏷 Details | `category`, `duration_seconds`, `duration_human`, `is_live`, `is_family_safe`, `thumbnail_url`, `tags`, `hashtags`, `links`, `description` | Category, length, flags, thumbnail, tags, hashtags, links and description text |
| 🌍 Language | `transcript_source`, `language`, `language_code`, `is_generated`, `language_matched`, `available_tracks` | Chosen caption language and type, and every caption track of the video |
| 📈 Statistics | `snippet_count`, `word_count`, `reading_time_min`, `speaking_rate_wpm` | Segment count, words, estimated reading time and speaking rate |
| 📚 Chapters | `chapters` | Chapters with `title`, `start`, `end` and their own `text` |
| ⏱ Transcript | `timestamped`, `non_timestamped` | Segments with `text`, `start` and `duration`, and the whole transcript as one text |
| 💾 Subtitle files | `srt`, `vtt`, `txt` | Subtitle text in the formats you selected |
| 🧭 Source | `source`, `source_input`, `position` | How the video was found (video, playlist, channel or search), the input that produced it and its order in the run |
| ✅ Status | `success`, `error_type`, `error_message`, `scraped_at`, `metadata_error` | Success flag, reason when no transcript was collected, UTC time, and why details were incomplete |

> **Note:** Fields that YouTube does not provide for a video are `null`. With `includeMetadata` switched off, the detail fields (subscribers, likes, comments, dates, category, flags, thumbnail, tags, hashtags, links, description, chapters and `metadata_error`) are left out of the row. Only the formats listed in `subtitleFormats` appear as `srt`, `vtt` or `txt`.

#### What data can't YouTube Transcript & Subtitles Scraper API extract?

- Transcripts for videos without a caption track: the row is saved with `success` set to `false` and is not charged.
- Translated captions: the Actor returns an available caption track and never translates one.
- Private videos, age-restricted videos and videos that were removed: they appear as failed rows with a reason.
- Comments text, video files or audio: only transcripts, subtitle files and video details are collected.

### How to use a YouTube subtitles scraper

1. Create a free [Apify account](https://console.apify.com/sign-up) or log in.
2. Open [YouTube Transcript & Subtitles Scraper API](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api) and go to the Input tab.
3. Add video, Shorts, playlist or channel links, @handles or search phrases to `urls`.
4. Set `maxItems` to the number of videos you want per input.
5. Choose `languages` in priority order and tick the `subtitleFormats` you need.
6. Click Start and watch the rows appear in the Output tab.
7. Switch between the output tables, then export the results as JSON, CSV or Excel.

### How much does it cost to run a YouTube subtitles scraper?

The Actor uses pay-per-event pricing: you pay for each video whose transcript was saved. Failed videos are listed but never charged. Platform usage is billed in addition. The price per result depends on your Apify plan:

| Apify plan | Price per result | Price per 1,000 results |
|---|---|---|
| Free | $0.0025 | $2.50 |
| Bronze | $0.00225 | $2.25 |
| Silver | $0.00215 | $2.15 |
| Gold | $0.002 | $2.00 |

Each run also starts with a start event of $0.00005 per GB of memory, with a minimum of one. This Actor runs with 1024 MB by default, so a run starts with one start event of $0.00005.

Worked example on the Gold plan: 1,000 saved transcripts cost 1,000 x $0.002 = $2.00, plus the $0.00005 start event, plus platform usage.

Free plan math: the $5 monthly credit of the Apify Free plan covers about 2,000 transcripts at the Free price of $0.0025, before platform usage.

#### Is this YouTube subtitles scraper free to try?

Yes. A new Apify account includes free monthly credit, so you can run the default input and review real output before you pay for anything. Check the [pricing tab](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api/pricing) for the current prices.

### Input

Only `urls` is required. You can start with the prefilled input below, which transcribes one video and the latest videos of one channel:

```json
{
  "urls": ["https://www.youtube.com/watch?v=aircAruvnKk", "@3blue1brown"],
  "maxItems": 10,
  "languages": ["en"],
  "includeMetadata": true,
  "subtitleFormats": ["srt"],
  "proxyConfiguration": { "useApifyProxy": false }
}
```

See the full [input schema](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api/input-schema) for every option.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `urls` | array | Yes | none (prefilled with a video and a channel) | Video, Shorts, playlist or channel links, @handles, channel IDs or plain search phrases |
| `maxItems` | integer | No | `10` | Maximum videos to transcribe per input URL; each channel, playlist or search gets up to this many videos independently |
| `languages` | array | No | `["en"]` | Caption languages in priority order; the first available language is used |
| `includeMetadata` | boolean | No | `true` | Adds likes, comments, subscribers, upload date, category, tags, links and chapters with their own transcript text |
| `subtitleFormats` | array | No | `["srt"]` | Subtitle files added to every video: `srt`, `vtt` or `txt` |
| `proxyConfiguration` | object | No | `{"useApifyProxy": false}` | Optional proxy settings; leave the default unless you need a specific setup |

#### Tricky fields

- `urls`:
  - ✅ Good: `"https://www.youtube.com/playlist?list=PLxxxxxxxxxxx"`, `"@channelname"` or `"machine learning basics"`
  - ❌ Bad: a link to another website, or an empty entry
  - A phrase that is not a link is treated as a YouTube search. A channel link without a tab uses its Videos tab; links ending in `/shorts` or `/streams` use those tabs.
- `maxItems`:
  - ✅ Good: `10` for a first test, `200` for a full channel
  - ❌ Bad: `0` or text such as `all`
  - > **Warning:** The limit applies to each input separately, so 3 channels with `maxItems` 10 can give up to 30 videos. Values above 5,000 are treated as 5,000.
- `languages`:
  - ✅ Good: `["en", "es"]` to try English first and Spanish second
  - ❌ Bad: listing a language that the video has no captions for and expecting a translation
  - > **Warning:** If none of your languages exists, the closest caption track is returned and `language_matched` is `false`.
- `subtitleFormats`:
  - ✅ Good: `["srt", "vtt"]`
  - ❌ Bad: `["pdf"]` (unknown formats are ignored and no subtitle file is added)

### Output

Results are stored in the run's dataset, and the Output tab shows them as eight tables: Videos, Full transcripts, Timestamped segments, Chapters, Caption tracks, Subtitle files, Video details and Run status. Export the data as JSON, CSV, Excel, XML or HTML, or read it through the API.

#### JSON example

This is one row for the prefilled input, with `subtitleFormats` set to `srt`:

```json
{
  "url": "https://www.youtube.com/watch?v=abcdEFGhij1",
  "video_id": "abcdEFGhij1",
  "title": "Example video title",
  "channel_name": "Example Channel",
  "channel_id": "UCexampleexampleexample01",
  "channel_url": "https://www.youtube.com/channel/UCexampleexampleexample01",
  "channel_subscribers": 120000,
  "view_count": 450000,
  "like_count": 18000,
  "comment_count": 900,
  "upload_date": "2024-05-01",
  "published_at": "2024-05-01T10:00:00-07:00",
  "category": "Education",
  "duration_seconds": 12,
  "duration_human": "12s",
  "is_live": false,
  "is_family_safe": true,
  "thumbnail_url": "https://example.com/thumbnail.jpg",
  "tags": ["example", "tutorial"],
  "hashtags": ["#example"],
  "links": ["https://example.com/resources"],
  "description": "Example description text.",
  "transcript_source": "captions",
  "language": "English",
  "language_code": "en",
  "is_generated": false,
  "language_matched": true,
  "available_tracks": [
    { "language": "English", "language_code": "en", "is_generated": false, "is_translatable": true }
  ],
  "snippet_count": 2,
  "word_count": 9,
  "reading_time_min": 0.0,
  "speaking_rate_wpm": 45,
  "chapters": [
    { "title": "Intro", "start": 0.0, "end": 12.0, "text": "Welcome to the example video." }
  ],
  "timestamped": [
    { "text": "Welcome to the example video.", "start": 0.5, "duration": 2.5 },
    { "text": "Today we cover one example.", "start": 3.0, "duration": 2.0 }
  ],
  "non_timestamped": "Welcome to the example video. Today we cover one example.",
  "srt": "1\n00:00:00,500 --> 00:00:03,000\nWelcome to the example video.\n\n2\n00:00:03,000 --> 00:00:05,000\nToday we cover one example.\n",
  "source": "video",
  "source_input": "https://www.youtube.com/watch?v=abcdEFGhij1",
  "position": 1,
  "success": true,
  "error_type": null,
  "error_message": null,
  "scraped_at": "2026-01-01T12:00:00Z",
  "metadata_error": null
}
```

The numbers in this example are made up for illustration. A video that could not be transcribed is saved as a row with `success` set to `false`, an `error_type` such as `TranscriptsDisabled`, `VideoPrivate`, `AgeRestricted` or `VideoUnavailable`, and a readable `error_message`.

At the end of each run, the Actor also saves a `RUN_SUMMARY` record in the key-value store with `totalTranscripts`, `charged`, `failed`, `skipped`, `durationSecs` and `spendLimitReached`.

#### Notes and limitations

- Only public videos with a caption track can be transcribed. Auto-generated and creator-written captions are both supported.
- A video that appears in several inputs is transcribed once.
- `word_count`, `reading_time_min` and `speaking_rate_wpm` stay `null` for Chinese, Japanese, Thai, Lao, Khmer and Burmese captions, which are written without spaces between words.
- Rows are saved as they finish, so their order can differ from your input order. Use `position` to sort them.
- The run stops cleanly when your spending limit is reached, and the rows saved so far are kept.

### Tips and advanced usage

- Start with a low `maxItems` such as 5 to check the output, then raise it for full channels and playlists.
- Switch `includeMetadata` off when you only need transcripts: rows get smaller and carry only title, channel, view count and length.
- Select only the subtitle formats you will use, since each format adds its own text to every row.
- Use the Chapters table to split long lectures into sections that already contain their transcript text.
- Use scheduled runs with the same channel input to collect new videos regularly.
- Use it as a YouTube subtitle downloader or a YouTube subtitle extractor when you need files for many videos at once.
- Use it as a YouTube transcript extractor for whole channels by adding the channel @handle to `urls`.

### Integrations and API

#### Can I use YouTube Transcript & Subtitles Scraper API as an API?

Yes. You can start runs and read results with the [Apify API](https://docs.apify.com/api/v2) or with the apify-client packages for Node.js and Python. The [API tab](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api/api) shows ready-to-copy code for this Actor.

#### How to scrape YouTube transcripts with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("data_minds/youtube-transcript-subtitles-scraper-api").call(run_input={
    "urls": ["https://www.youtube.com/watch?v=aircAruvnKk", "@3blue1brown"],
    "maxItems": 10,
    "languages": ["en"],
    "includeMetadata": True,
    "subtitleFormats": ["srt"],
    "proxyConfiguration": {"useApifyProxy": False},
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["word_count"])
```

#### Can I integrate YouTube Transcript & Subtitles Scraper API with other apps?

Yes. Connect it to Make, Zapier, Google Sheets, Slack and other apps through Apify integrations, trigger your own services with [webhooks](https://docs.apify.com/integrations/webhooks), or run it on a schedule from the Apify Console.

#### Can I use YouTube Transcript & Subtitles Scraper API with AI agents (MCP)?

Yes. AI agents can call this Actor through the Apify MCP server. Open the [MCP tab](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api/api/mcp) for the connection details.

### Other YouTube and search scrapers

| Actor | What it does |
|---|---|
| 🔎 [YouTube Search API](https://apify.com/data_minds/youtube-search-api) | Search YouTube for videos, channels and playlists with enriched engagement, channel, and transcript data. |
| 🌐 [Website Content Crawler](https://apify.com/data_minds/website-content-crawler) | Turns any website into clean text, Markdown and page metadata for RAG pipelines, LLM knowledge bases and SEO content audits. |
| 🎬 [YouTube Transcript Scraper](https://apify.com/data_minds/youtube-transcript-scraper) | Extracts YouTube transcripts, subtitles and captions in bulk, plus channel, views, likes, keywords and description, into a clean dataset. |

### FAQ

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

Scraping publicly available data is generally considered legal in many places, but the rules depend on your country, the data and how you use it. This Actor only reads public videos. Read the [Apify guide on web scraping legality](https://blog.apify.com/is-web-scraping-legal/) and check YouTube's terms. This is not legal advice.

#### How does YouTube Transcript & Subtitles Scraper API work?

You give it YouTube video, Shorts, playlist or channel links, @handles or search phrases, plus your preferred languages. Channels, playlists and searches expand into their videos up to `maxItems`. For each video you get one row with the transcript, optional details and subtitle files, which you can open in the Output tab or export.

#### Why scrape YouTube transcripts?

Transcripts turn spoken video into searchable text. Teams use them to build AI training data, feed RAG knowledge bases, create subtitles for accessibility, repurpose videos into blog posts, make study notes from lectures, and run content research across a channel. Timestamps and chapters keep every quote linked to its place in the video.

#### Why did I get fewer results than expected?

Common reasons are videos without captions, private or removed videos, and a low `maxItems`, which applies to each input separately. A video that appears in several inputs is also transcribed only once. Open the Run status table to see the `error_type` and `error_message` of every video that was skipped or failed.

#### Is YouTube Transcript & Subtitles Scraper API not working?

First open the Run status table and read the `error_message` of the affected rows, because many failures come from private videos, missing captions or a mistyped link. Then try a smaller input. If the problem remains, open a report in the Issues tab with your run link, and the maintainers will look at it.

#### Do I need a YouTube account, cookies or an API key?

No. The Actor works with public videos, so you do not need a YouTube account, cookies or a YouTube API key. You only need an Apify account to run it. Videos that are private or restricted to signed-in viewers cannot be transcribed and are reported as failed rows with a reason.

#### Can I download YouTube subtitles as SRT or VTT files?

Yes. Tick `srt`, `vtt` or `txt` in `subtitleFormats` and each video row gets the matching subtitle text in a field of the same name. Copy the text into a file, or read it through the API. The Subtitle files table in the Output tab shows all three formats side by side.

#### Can I get a YouTube transcript in another language?

You can choose from 31 caption languages by listing language codes in `languages`, in priority order, if the video offers them. The Actor does not translate captions. When none of your languages exists, it returns the closest available track and sets `language_matched` to `false`, so you can filter those rows out.

### Support and feedback

Found a problem or missing a feature? Open the [Issues tab](https://apify.com/data_minds/youtube-transcript-subtitles-scraper-api/issues/open). For custom solutions or questions, contact hello.dataminds@gmail.com. Built and maintained by the [data_minds](https://apify.com/data_minds) team on Apify.

This Actor is an independent tool and is not affiliated with or endorsed by YouTube. Collect only public data, and make sure your use complies with applicable laws and the terms of the platforms involved.

# Changelog

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

# Actor input Schema

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

Video, Shorts, playlist or channel links, @handles, channel IDs or plain search phrases. Add as many as you like; channels, playlists and searches expand into their videos.

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

Maximum videos to transcribe per input URL. Each channel, playlist or search gets up to this many videos independently.

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

Languages in priority order. The first available language is used. If none matches, the closest track is returned (flagged by language_matched).

## `includeMetadata` (type: `boolean`):

Add likes, comments, subscribers, upload date, category, tags, links and chapters with their own transcript text.

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

Ready-to-save subtitle files added to every video.

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

Optional proxy settings. Leave the default unless you need a specific setup.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=aircAruvnKk",
    "@3blue1brown"
  ],
  "maxItems": 10,
  "languages": [
    "en"
  ],
  "includeMetadata": true,
  "subtitleFormats": [
    "srt"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per video with key numbers.

## `transcript` (type: `string`):

Plain-text transcript per video.

## `segments` (type: `string`):

One row per transcript segment with start and duration.

## `chapters` (type: `string`):

One row per chapter with its own transcript text.

## `tracks` (type: `string`):

One row per available caption language.

## `subtitles` (type: `string`):

SRT, VTT and TXT text per video.

## `details` (type: `string`):

Channel and engagement details.

## `errors` (type: `string`):

Success flag and error reason per input.

# 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=aircAruvnKk",
        "@3blue1brown"
    ],
    "maxItems": 10,
    "languages": [
        "en"
    ],
    "subtitleFormats": [
        "srt"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_minds/youtube-transcript-subtitles-scraper-api").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=aircAruvnKk",
        "@3blue1brown",
    ],
    "maxItems": 10,
    "languages": ["en"],
    "subtitleFormats": ["srt"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_minds/youtube-transcript-subtitles-scraper-api").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=aircAruvnKk",
    "@3blue1brown"
  ],
  "maxItems": 10,
  "languages": [
    "en"
  ],
  "subtitleFormats": [
    "srt"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_minds/youtube-transcript-subtitles-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_minds/youtube-transcript-subtitles-scraper-api"
        }
    }
}
```

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/wsI3KHlHbANHj7h6N/builds/iQste2nEXDf47HcT5/openapi.json