# YouTube Transcript AI: Subtitles, SRT & Speakers (`deapi/youtube-transcript-ai`) Actor

AI YouTube transcription from the audio, so videos with no captions work too. Get a timestamped YouTube transcript with word timings, speaker labels and SRT/VTT subtitles for videos, Shorts and finished livestreams. 90+ languages, about $0.001/min. No login or API key.

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

## Pricing

from $1.06 / 1,000 transcript, per minute of videos

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 AI: Subtitles, SRT & Speakers

Transcribe any public YouTube video to text from the audio — even videos with **no captions**, Shorts and finished livestreams. Get the **YouTube transcript** with timestamps, speaker labels and SRT/VTT subtitles. Paste one link or a thousand, and **YouTube Transcript AI** returns the full text, sentence or word-level timings and ready-to-use subtitle files. No YouTube login, no API key, no cookies, nothing to download.

**deAPI video tools**

- Need what happens on screen instead of what is said? → [AI Video Analyzer: Scenes, Events & Timestamps](https://apify.com/deapi/tiktok-video-scene-analyzer)
- Working with TikTok? → [TikTok Transcript from Audio: SRT, VTT & Speakers](https://apify.com/deapi/tiktok-transcript-scraper)
- Working with Twitch or Kick? → [Twitch & Kick VOD Transcriber: SRT, VTT & Speakers](https://apify.com/deapi/twitch-kick-transcript-scraper)

### What does YouTube Transcript AI do?

Most YouTube transcript tools copy the caption track. That works until it does not: plenty of videos have **no captions at all**, auto-captions are switched off, missing for the language spoken, or so rough they are unusable. This Actor does not read captions. It **listens to the audio and transcribes it** with an AI speech recognition model, so every public video comes back as clean, punctuated text with timings — whether or not YouTube ever captioned it.

It works as a YouTube transcript API: paste video links, get back text, timings, speakers and subtitle files as structured data.

### Why transcribe from the audio, not captions?

- **Works without captions** — the audio is transcribed, not the caption track.
- **Word-level timings** — every word, with a confidence score.
- **Speaker labels** — who said what, for podcasts, interviews and panels.
- **Shorts and finished livestreams** — same run, same rate.
- **Up to 10 hours per video** — full lectures, streams and conferences.
- **SRT and VTT subtitles, properly split** — two-line cues, ready for an editor.
- **Private or deleted videos detected before you are charged** — always.
- **Priced at cost** — about a tenth of a cent per minute of audio.

| | YouTube captions | **YouTube Transcript AI** |
|---|---|---|
| Videos with no captions | ❌ nothing to read | ✅ transcribed from the audio |
| Punctuation | Often poor on auto-captions | ✅ full sentences |
| **Word-level timings** | ❌ | ✅ every word, with confidence |
| **Speaker labels** | ❌ | ✅ included |
| Subtitle files | Raw caption track | ✅ SRT + VTT, two-line cues |
| Price per 10-minute video | — | **$0.0181** |

### What data can you get?

| Data | Details |
|---|---|
| 📝 **Full transcript** | Clean, punctuated text of everything spoken in the video. |
| ⏱️ **Timestamps** | At the level you choose — one per sentence, one for every single word, or none at all. Sentence timing is in the base price. |
| 🗣️ **Speaker labels** | `SPEAKER_00`, `SPEAKER_01` … on every segment and word, for podcasts, interviews, panels and webinars. |
| 🎬 **SRT and VTT subtitles** | Properly split, two lines, readable. Drop them straight into a video editor, a player or your CMS. |
| 🌍 **Language** | 90+ languages. Set the spoken language for the most reliable result, or leave it on auto-detect. |
| 📺 **Video metadata** (optional) | Title, channel, description, view count and like count. |
| 🔢 **Confidence scores** | Per segment and per word, so you can flag the passages worth a human check. |

### How to transcribe a YouTube video

1. Open the Actor and paste one or more links into **YouTube video URLs**.
2. Pick a **timestamp level** — segment is the default and suits subtitles and reading.
3. Switch on **Label speakers** if the video has more than one voice.
4. Pick the **spoken language** if you know it. Auto-detect can misidentify the language, which lowers accuracy.
5. Click **Start**. Results appear row by row.
6. Download the dataset as JSON, CSV or Excel, or pull it from the [Apify API](https://docs.apify.com/api/v2).

A step-by-step walkthrough with code is in the [tutorial](#tutorial-transcribe-youtube-videos-with-the-api) below.

#### Which links work

| Link | Works |
|---|---|
| `youtube.com/watch?v=7qaiNfoMRts` | ✅ video |
| `youtu.be/7qaiNfoMRts` | ✅ share link |
| `youtube.com/shorts/<id>` | ✅ Short |
| `youtube.com/live/<id>` | ✅ finished livestream |
| `m.youtube.com/…`, `music.youtube.com/watch?v=…`, `youtube.com/embed/<id>` | ✅ rewritten for you |
| `youtube.com/@channel`, `youtube.com/playlist?list=…` | ❌ paste the individual videos |
| A stream that is live right now | ❌ wait until it ends |

Paste the same video twice in any two of those forms — a share link and a timestamped watch link, say — and it is transcribed, and billed, **once**.

#### How fast is YouTube transcription?

A 72-second video is transcribed in under 30 seconds. Long videos go many times faster than real time, so a one-hour lecture takes a few minutes. Several videos run in parallel, so a batch of short videos finishes in about the time one of them takes.

### Input

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=7qaiNfoMRts"
  ],
  "timestampLevel": "segment",
  "diarize": false,
  "language": "en",
  "includeSubtitles": true,
  "includeMetadata": false,
  "maxConcurrency": 3
}
```

### Output

One row per video, downloadable as JSON, CSV or Excel. This is the real result for the example above, shortened:

```json
{
  "url": "https://www.youtube.com/watch?v=7qaiNfoMRts",
  "videoId": "7qaiNfoMRts",
  "sourceType": "video",
  "status": "success",
  "hasSpeech": true,
  "durationSeconds": 72,
  "language": "en",
  "languageConfidence": 0.9937,
  "wordCount": 176,
  "timestampLevel": "segment",
  "text": "Every builder wants powerful AI in their app without queues, GPU bills, or weeks of setup. But today, you either pay premium prices or fight with complex infrastructure...",
  "segments": [
    {
      "start": 0,
      "end": 28.93,
      "text": "Every builder wants powerful AI in their app without queues, GPU bills, or weeks of setup...",
      "avg_logprob": -0.0544
    }
  ],
  "speakers": [],
  "srt": "1\n00:00:00,000 --> 00:00:02,913\nEvery builder wants powerful AI in their\napp\n\n2\n00:00:02,913 --> 00:00:05,892\nwithout queues, GPU bills, or weeks of\nsetup.\n\n...",
  "vtt": "WEBVTT\n\n00:00:00.000 --> 00:00:02.913\nEvery builder wants powerful AI in their\napp\n\n...",
  "billedMinutes": 2,
  "pricingOption": "standard"
}
```

With **word-level timestamps** on, each segment also carries a `words` list — `{ "word": "Every", "start": 0.0, "end": 0.32, "score": -0.11 }` — and with **speaker labels** on, every segment and word carries a `speaker`.

With **video metadata** switched on, each row also carries:

```json
{
  "metadata": {
    "title": "deAPI – Build AI apps with low cost API",
    "channel": "deAPI",
    "description": "deAPI is a low-cost and scalable API for running open-source AI models...",
    "viewCount": 720606,
    "likeCount": 13
  }
}
```

A very long video produces more text than a single dataset row is allowed to hold. When that happens the heavy fields are written to the run's key-value store and linked as `textUrl`, `srtUrl`, `vttUrl` and `segmentsUrl`, and the row is flagged `oversized: true`. Nothing is ever truncated.

### How much does it cost?

**$0.0075 per video + $0.00106 per minute (standard).** Word-level timings or speaker labels are $0.01063 per video + $0.00154 per minute.

Charged **per transcribed video plus every started minute of it** — so a 72-second video bills two minutes. The per-video fee covers the fixed setup every transcription job pays; the per-minute rate covers the audio itself. One price on every Apify plan. Nothing else is metered: platform usage is on us, and subtitles, confidence scores and sentence timestamps are all in the base price.

| What you asked for | Per video | Per minute |
|---|---|---|
| Plain text, or sentence timestamps | **$0.0075** | **$0.00106** |
| Word-level timings, or speaker labels, or both | **$0.01063** | **$0.00154** |
| Video metadata (optional add-on) | $0.00625 | — |

Word timings and speaker labels sit on the same higher rate, and **picking both costs no more than picking one**.

| Video | Sentence timing | Word timing or speakers |
|---|---|---|
| A 1-minute Short | $0.00856 | $0.01217 |
| A 3-minute Short | $0.01068 | $0.01525 |
| A 10-minute video | $0.0181 | $0.02603 |
| A 1-hour podcast or lecture | $0.0711 | $0.10303 |
| A 3-hour livestream | $0.1983 | $0.28783 |
| A 10-hour stream (the ceiling) | $0.6435 | $0.93463 |

That is **$8.56 per 1,000 one-minute Shorts** and about **$0.001 per minute** on longer videos — the price of the speech recognition itself plus Apify's platform costs and fee, with no markup beyond that.

Videos that fail — private, members-only, deleted, region-locked, still live, longer than 10 hours — are **never charged**. Neither are videos skipped because a run cost limit or a free-plan allowance was reached. Every one of them still gets a row explaining what happened.

Set **maximum cost per run** to whatever you are comfortable with. The Actor prices each video before it starts work and skips anything the remaining budget cannot cover, so a run cannot overshoot the cap you set.

**Free plan:** 3 videos per run, 30 minutes maximum each, 60 transcribed minutes per calendar month, resetting at 00:00 UTC on the 1st. Free-plan transcription also shares a daily capacity across all free users; when it runs out, videos are skipped at no charge until 00:00 UTC. Any paid Apify plan removes every limit.

### Use cases

| Use case | Why it needs a transcript |
|---|---|
| **Content repurposing** | Turn a video into a blog post, newsletter, show notes, quotes and social posts. |
| **SEO and chapters** | Publish a searchable text version and build chapter markers from the timestamps. |
| **Research and monitoring** | Track what creators, competitors or politicians actually said, with the timestamp to prove it. |
| **Podcasts and interviews** | Speaker-labelled transcripts of long conversations, ready to quote. |
| **Education** | Lecture and tutorial transcripts for notes, search and study guides. |
| **Accessibility** | Ship real SRT and VTT subtitles for videos that were never captioned. |
| **RAG and AI agents** | Feed timestamped, speaker-labelled text into a vector store or an LLM pipeline. |
| **Clip finding** | Search the text for the moment something was said, and cut on the word timings. |

### Tutorial: transcribe YouTube videos with the API

A short walkthrough from one video in the Console to a scheduled batch from code.

#### 1. One video in the Console

Open the Actor, keep the prefilled link `https://www.youtube.com/watch?v=7qaiNfoMRts`, set **Spoken language** to English and click **Start**. After about half a minute the **Transcripts** view shows one row: 72 seconds, 176 words, language `en`. Open the **Subtitles** view and copy the `srt` field into a `.srt` file — it plays in VLC or YouTube Studio as is.

#### 2. The same run from Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("deapi/youtube-transcript-ai").call(run_input={
    "videoUrls": ["https://www.youtube.com/watch?v=7qaiNfoMRts"],
    "language": "en",
    "timestampLevel": "segment",
    "includeSubtitles": True,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["status"] != "success":
        print(row["url"], row["error"])
        continue
    print(row["videoId"], row["durationSeconds"], "s,", row["wordCount"], "words")
    with open(f'{row["videoId"]}.srt', "w", encoding="utf-8") as srt:
        srt.write(row["srt"] or "")
```

#### 3. From JavaScript or cURL

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('deapi/youtube-transcript-ai').call({
    videoUrls: ['https://www.youtube.com/watch?v=7qaiNfoMRts'],
    language: 'en',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].text);
```

```bash
curl -X POST "https://api.apify.com/v2/acts/deapi~youtube-transcript-ai/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls": ["https://www.youtube.com/watch?v=7qaiNfoMRts"], "language": "en"}'
```

#### 4. Speakers and word timings

For a podcast or an interview, set `"diarize": true` and `"timestampLevel": "word"`. Every word then carries `start`, `end`, `score` and `speaker`, and the SRT cues are prefixed with `[SPEAKER_00]`. Both options together cost the same as either one.

#### 5. A whole channel or playlist

This Actor takes video URLs. To transcribe a channel or a playlist, list its videos first with a YouTube scraper (for example [streamers/youtube-scraper](https://apify.com/streamers/youtube-scraper)), then pass the `url` field of its dataset into **YouTube video URLs**. Set **Videos in parallel** to 5–10 for large batches and a **maximum cost per run** to cap the spend.

#### 6. Keep it running

Save your input as a **Task**, add a **Schedule** (for example daily), and attach a **webhook** or an integration (Make, Zapier, n8n, Google Drive) to send each new transcript where you need it.

### YouTube transcript API and integrations

Every Apify Actor has a [REST API](https://docs.apify.com/api/v2), a [scheduler](https://docs.apify.com/platform/schedules), [webhooks](https://docs.apify.com/platform/integrations/webhooks) and official [JavaScript and Python clients](https://docs.apify.com/api/client/js). It also runs from Make, Zapier, n8n and as a tool for AI agents through the Apify MCP server.

### FAQ

#### Does it work on videos without captions?

Yes — that is the point of it. The audio is transcribed with AI speech recognition, so it does not matter whether the video has captions, auto-captions, captions in a different language, or none at all.

#### Is it better than YouTube's auto-captions?

Usually, yes. You get properly punctuated sentences, word timings with confidence scores, speaker labels and cleanly split subtitle cues. Auto-captions are often poorly punctuated, have no speakers, and are missing on many videos.

#### How do I convert a YouTube video to text?

Paste the video link into **YouTube video URLs** and click **Start**. The `text` field of the result is the full transcript; export the dataset as JSON, CSV or Excel, or read it from the API.

#### How do I download a YouTube transcript?

Open the run's **Storage** tab and export the dataset, or copy the `srt` / `vtt` field from the **Subtitles** view into a `.srt` or `.vtt` file. From code, read the dataset items as in the [tutorial](#tutorial-transcribe-youtube-videos-with-the-api).

#### Is there a YouTube transcript API?

Yes — this Actor is one. Call it over the Apify REST API (see the cURL example in the tutorial), from the JavaScript or Python client, or as a tool for AI agents through the Apify MCP server.

#### Can I generate subtitles for a YouTube video?

Yes. It works as a subtitle generator: every run returns SRT and VTT files built from the audio, ready for YouTube Studio, a video editor or a web player.

#### Can I get a YouTube Shorts transcript?

Yes. Paste `youtube.com/shorts/<id>` and it is handled like any other video. A one-minute Short costs $0.00856, a three-minute one $0.01068.

#### Can I transcribe a livestream?

A finished one, yes — `youtube.com/live/<id>` works once the stream has ended and the recording is available. A stream that is still live has no final length and is rejected up front, at no charge.

#### How long a video can it handle?

Up to 10 hours per video. Anything longer — or a livestream that is still running — is rejected before work starts, at no charge, with a message saying so.

#### Can I transcribe a whole channel or playlist?

Not from the channel or playlist link itself — paste the individual videos. A YouTube scraper can list them for you; see step 5 of the [tutorial](#5-a-whole-channel-or-playlist).

#### Can I transcribe many videos in bulk?

Yes. Paste as many links as you like into one run; several are transcribed in parallel and each produces its own row. Duplicates are collapsed before anything is charged.

#### Can I get SRT or VTT subtitles?

Yes, both, free of charge, on every video with timing. They are split into readable two-line cues, and speaker labels are included in the cue text when speaker labels are on.

#### Which languages are supported?

More than 90, auto-detected by default.

#### How accurate is it?

On clear speech the transcript is close to what a careful human would type, with punctuation and capitalisation. Accuracy drops with heavy music, crosstalk and strong background noise; each segment and word carries a confidence score so you can find the passages worth a second look, and setting the spoken language helps more than anything else.

#### Should I set the language or leave auto-detect on?

Set it whenever you know it. Auto-detect can misidentify the language, which lowers transcription accuracy, especially on videos that open with music or an intro.

The setting applies to every URL in the run. For videos in different languages, start one run per language, or keep auto-detect and check `language` and `languageConfidence` on each row. A confidence below about 0.8 on a video with speech means it is worth re-running with the language set.

#### What happens if a video has no speech?

You get a row with `hasSpeech: false` and an empty transcript, not an error. Music videos and silent clips are valid outcomes. The video is still billed, because the audio was still processed.

#### Why did a video fail?

Almost always because it is unreachable: private, members-only, age-restricted, deleted, region-locked, or still live. Failures are detected before the work starts and are never charged. The reason is in the row's `error` field.

#### Do I need a YouTube account or API key?

No. No login, no cookies, no YouTube API key, no browser extension. Public videos only.

#### Is it legal to transcribe YouTube videos?

The Actor reads publicly available videos, the same ones any viewer can open. You are responsible for what you do with the output — quoting, publishing and re-using someone's video is subject to copyright and to YouTube's terms, exactly as it is if you transcribe it by hand. Please respect YouTube's terms and the rights of the creators.

### Support / feedback

Found a bug, hit a video that will not transcribe, or want a feature? Open a ticket in this Actor's **Issues** tab on its Apify Store page and include the video URL and run ID where you can.

# Actor input Schema

## `videoUrls` (type: `array`):

Links to YouTube videos. Regular videos (`youtube.com/watch?v=…`), short links (`youtu.be/…`), **Shorts** (`youtube.com/shorts/…`) and **finished livestreams** (`youtube.com/live/…`) all work, and `m.youtube.com`, `music.youtube.com` and embed links are rewritten for you. The audio is transcribed, so videos **without captions** work too. Playlist and channel pages are rejected — paste the individual videos. A stream that is still live cannot be transcribed until it ends. Maximum 10 hours per video. Private, deleted and region-locked videos are detected before anything is charged. **Free plan: 3 videos per run, 30 minutes maximum each, 60 transcribed minutes per calendar month (resets 00:00 UTC on the 1st), within a daily capacity shared by all free users. Paid plans remove every limit.**

## `timestampLevel` (type: `string`):

How finely the transcript is timed. **Segment** gives one timestamp per sentence — right for subtitles, reading, chapters and jumping to the moment something was said, and included in the base price. **Word** times every single word — right for clip cutting, word-by-word captions and search. **None** returns plain text only. Word moves the video onto the precision rate ($0.01063 per video + $0.00154 a minute, against $0.0075 + $0.00106), and choosing speaker labels as well costs nothing extra on top.

## `diarize` (type: `boolean`):

Detect who is speaking and tag every line with a speaker (SPEAKER_00, SPEAKER_01, …). Use it for podcasts, interviews, panels, webinars and any video with more than one voice. Speaker labels need timing to attach to, so switching this on together with **None** still returns sentence-level timing. Moves the video onto the precision rate ($0.01063 per video + $0.00154 a minute, against $0.0075 + $0.00106); if you already picked Word timestamps, adding speakers costs nothing extra.

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

Pick the language spoken in the video whenever you know it. Auto-detect can misidentify the language, which lowers transcription accuracy. One language applies to every URL in the run, so split mixed-language batches into separate runs, or keep auto-detect and check `languageConfidence` in the output. The dropdown lists the 29 most requested languages; anything else is transcribed on auto-detect.

## `includeSubtitles` (type: `boolean`):

Return ready-to-use subtitle files as `srt` and `vtt` fields — paste them straight into a video editor, a player or a CMS. Free of charge. Subtitles need timing to exist, so they are produced at every timestamp level except None, and also at None when speaker labels are switched on. On very long videos the files are saved to the run's key-value store and linked as `srtUrl` and `vttUrl` instead of being inlined, so nothing is ever truncated.

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

Attach the video's own data to each row: title, channel, description, view count and like count. Turns one run into transcript + video context for content research. Optional add-on of $0.00625 per video — leave it off and you are not charged for it.

## `maxConcurrency` (type: `integer`):

How many videos are transcribed at the same time. Higher finishes a large batch sooner. It has no effect on price — you are charged per video and per minute of audio either way, and platform usage is on us.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=7qaiNfoMRts"
  ],
  "timestampLevel": "segment",
  "diarize": false,
  "language": "auto",
  "includeSubtitles": true,
  "includeMetadata": false,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `transcripts` (type: `string`):

One row per video: the full transcript text, timed segments (with word-level timings and speaker labels when requested), SRT and VTT subtitles, detected language, video length, word count and the minutes billed. Every URL you submit produces a row. Videos that could not be transcribed carry status 'failed' with an 'error' field, and are not charged. Videos left out because a free-plan allowance or a run cost limit was reached carry status 'skipped' with the reason in 'error', and are not charged either. On very long videos the heavy fields are saved as files and linked from 'textUrl', 'srtUrl', 'vttUrl' and 'segmentsUrl'.

# 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 = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=7qaiNfoMRts"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deapi/youtube-transcript-ai").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 = { "videoUrls": ["https://www.youtube.com/watch?v=7qaiNfoMRts"] }

# Run the Actor and wait for it to finish
run = client.actor("deapi/youtube-transcript-ai").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 '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=7qaiNfoMRts"
  ]
}' |
apify call deapi/youtube-transcript-ai --silent --output-dataset

```

## MCP server setup

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

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/n7mxMgz3YFKd7xTAe/builds/TFVsDD0Uof1sOsCXg/openapi.json