# YouTube Video Transcript API - Text, Timestamps, JSON (`om_kh/video-transcript-api`) Actor

Video transcript API for LLMs and RAG: YouTube videos or whole channels to JSON with full text and timestamped segments. Also views, likes, upload date, channel subscribers, optional SRT/VTT and RAG chunks. MCP-ready. $2.50 per 1,000 transcripts, failed videos never charged.

- **URL**: https://apify.com/om_kh/video-transcript-api.md
- **Developed by:** [Khandji Omar](https://apify.com/om_kh) (community)
- **Categories:** Videos, Social media, AI
- **Features:** Limited permissions
- **Stats:** 15 total users, 3 monthly users, 99.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.38 / 1,000 transcripts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Video Transcript API — Text, Timestamps, JSON

A developer-first **video transcript API**: send YouTube video URLs or IDs, get back JSON with the full text and timestamped segments. Built for LLM summarisation, RAG pipelines, AI agents and backend jobs — as a batch run, a live HTTP endpoint or an MCP tool.

> **Main YouTube transcript tool:** [YouTube Transcript Scraper](https://apify.com/om_kh/youtube-transcript-api) runs the same engine, with **$1 per 1,000 transcripts from 12 November 2026**. This Actor stays available with its own input and price.

### In short: what you give, what you get, what it costs

| | |
|---|---|
| **You give** | YouTube video links or IDs (up to 1,000 per run), as a batch run, a live HTTP call or an AI agent tool |
| **We do** | Read YouTube's own captions, human-written first, in the language you choose |
| **You get** | JSON per video: the full text and timestamped segments, ready for summaries, search or AI |
| **It costs** | $2.50 per 1,000 transcripts: 100 videos = **$0.25**, + $0.001 per run from Nov 24, 2026 (no start fee before). Videos without captions are never charged; the first result of every run is free |
| **It does not** | Make a transcript when the video has no captions (that video is reported and costs $0), sign in, or use an API key |

A real result row is shown further down this page.

### Free tier — 1 result free on every run

**The first 1 result of every run is free**, on every run you ever make — not a one-off trial. One guard: the free allowance never covers more than half of a run, so the offer stays sustainable.

### What does this video transcript API do?

Give it YouTube video links or IDs. For every video it returns:

- the **full transcript as one clean string**, ready for an LLM, a search index or a spreadsheet;
- **timestamped segments** (`start`, `duration`, `text`) for subtitles, players or chunked RAG;
- the **language**, whether captions are **human-written or auto-generated**, and every other caption language available;
- the video **title**, **channel**, **duration**, **word count** and segment count.

Watch links, `youtu.be` short links, Shorts, embeds and bare 11-character IDs all work, mixed in one list.

### Compared with johnvc/YoutubeTranscripts

Read on the Store on 2026-10-23 (YouTube Transcript & Subtitles Scraper API). Where it does better, this section says so.

- **Built on the site's own data**, not a resold scraper: no second Actor between you and the source.
- **Free results on every run** and a hard cost cap (`maxTotalChargeUsd`).
- **Price:** $2.50 per 1,000 here, $2.75 there.

### Why use it

- **One predictable JSON shape** for every video, with a per-video error instead of a crashed run.
- **One HTTP call** — the run-sync endpoint returns the transcripts as JSON, ideal for a backend or an agent.
- **MCP tool `video_transcript`** — plug it into Claude, Cursor or any MCP client.
- **No keys, no cookies, no OAuth** — nothing to rotate.
- **$0.0025 per transcript, failures free**, with a hard spending cap per run.

### How to get YouTube transcripts in 3 steps

1. Click **Try for free** and paste one or more YouTube links in **YouTube videos**.
2. Optional: set a **Preferred language** (`en`, `fr`, `es`, `de`, …). Leave it empty for English, then the video's default.
3. Click **Start**. Download the results as **JSON, CSV, Excel, HTML or XML**, or read them from the API.

### Input

| Field | Type | What it does |
|---|---|---|
| `videos` | array | YouTube watch URLs, `youtu.be` links, Shorts, embeds or 11-character video IDs. Up to 1,000 per run. |
| `language` | string | Preferred two-letter caption language. Human-written captions are always preferred over auto-generated ones. |
| `includeSegments` | boolean | `true` (default) adds timestamped segments; `false` returns plain text only. |
| `channels` | array | Whole channels: links, `@handles` or channel IDs. Newest videos first. Use with or instead of `videos`. |
| `maxVideosPerChannel` | integer | 1 to 500 per channel. Default 10. |
| `publishedAfter`, `publishedBefore` | string | Keep only channel videos uploaded in this date range (`YYYY-MM-DD`). |
| `includeStats` | boolean | `true` (default) adds likes, comment count, upload date and the channel's subscribers, handle and avatar. Views, description, channel and thumbnail are always included. |
| `translateTo` | string | *Experimental.* Asks YouTube for a machine translation (`fr`, `es`…). YouTube often refuses automated translation requests; you then get the original language plus a `translation_note`, never a failed video. |
| `outputFormats` | array | Any of `srt`, `vtt`, `chunks`: ready-to-use subtitle files and ~250-word RAG chunks with start/end seconds. |
| `proxyConfiguration` | object | Uses Apify Proxy by default. YouTube blocks datacenter IPs, so leave it on. |
| `youtube_url`, `videoUrl`, `channel_url`, `max_videos`, `start_date`, `end_date`, `targetLanguage` | | Field names used by other YouTube transcript Actors, accepted as aliases of `videos`, `channels`, `maxVideosPerChannel`, `publishedAfter`, `publishedBefore`, `language`. Your own names win. |
| `maxTotalChargeUsd` | number | Hard spending cap for the run. |

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
    "jNQXAC9IVRw"
  ],
  "language": "en",
  "includeSegments": true
}
```

### Output

One dataset item per video:

A real row from this Actor's latest run on Apify (2026-10-24; long texts are cut and people's names hidden here, your dataset has them in full):

```json
{
  "video_id": "dQw4w9WgXcQ",
  "video_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)",
  "channel": "Rick Astley",
  "language": "en",
  "is_generated": false,
  "available_languages": [
    "de-DE",
    "en"
  ],
  "duration_seconds": 211.32,
  "segment_count": 61,
  "word_count": 487,
  "text": "[♪♪♪] ♪ We're no strangers to love ♪ ♪ You know the rules and so do I ♪ ♪ A full commitment's what I'm thinking of ♪ ♪ You wouldn't get t...",
  "segments": [
    {
      "start": 1.36,
      "duration": 1.68,
      "text": "[♪♪♪]"
    },
    {
      "start": 18.64,
      "duration": 3.24,
      "text": "♪ We're no strangers to love ♪"
    }
  ],
  "source": "youtube",
  "channel_id": "UCuAXFkgsw1L7xaCfnd5JJOw",
  "channel_url": "https://www.youtube.com/channel/UCuAXFkgsw1L7xaCfnd5JJOw",
  "description": "The official video for “Never Gonna Give You Up” by Rick Astley. \n\nNever: The Autobiography 📚 OUT NOW! \nFollow this link to get your copy...",
  "keywords": [
    "rick astley",
    "Never Gonna Give You Up"
  ],
  "view_count": 1830096493,
  "video_length_seconds": 213,
  "thumbnail_url": "https://i.ytimg.com/vi/dQw4w9WgXcQ/sddefault.jpg",
  "is_live": false,
  "duration_human": "3:33",
  "hashtags": [
    "NeverGonnaGiveYouUp",
    "OfficialMusicVideo"
  ],
  "is_private": false,
  "allow_ratings": true,
  "playable_in_embed": true,
  "caption_track_count": 6,
  "is_translatable": true,
  "translation_languages": [
    "ar",
    "zh-Hant"
  ],
  "fetched_at": "2026-10-24T19:00:44Z",
  "like_count": 19495337,
  "comment_count": 2400000,
  "published_at": "2009-10-24",
  "channel_handle": "(hidden here)",
  "channel_subscribers": 4550000,
  "channel_thumbnail_url": "https://yt3.ggpht.com/_ShEGOdg-t5YGJse14Ooq6FYBZqX_QSlhaTNjG06miYusm5lWm1UroLyVxnYtahADfRTVLtuVQ=s176-c-k-c0x00ffffff-no-rj",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "status": "success",
  "selected_language": "en",
  "is_auto_generated": false,
  "transcript_text": "[♪♪♪] ♪ We're no strangers to love ♪ ♪ You know the rules and so do I ♪ ♪ A full commitment's what I'm thinking of ♪ ♪ You wouldn't get t...",
  "channel_username": "(hidden here)",
  "thumbnail": "https://i.ytimg.com/vi/dQw4w9WgXcQ/sddefault.jpg",
  "transcript": [
    {
      "start": 1.36,
      "duration": 1.68,
      "text": "[♪♪♪]",
      "end": 3.04
    },
    {
      "start": 18.64,
      "duration": 3.24,
      "text": "♪ We're no strangers to love ♪",
      "end": 21.88
    }
  ]
}
```

| Field | Description |
|---|---|
| `video_id`, `video_url` | The video, normalised to a watch URL |
| `title`, `channel` | Video title and channel name |
| `language`, `is_generated` | Caption language and whether YouTube auto-generated it |
| `available_languages` | Every caption language the video offers |
| `text` | The full transcript as one string |
| `segments` | `[{text, start, duration}]`, in seconds |
| `duration_seconds`, `segment_count`, `word_count` | Size of the transcript |
| `view_count`, `like_count`, `comment_count` | Video statistics. Likes are exact; YouTube rounds the comment count on very large videos |
| `published_at` | Upload date (`YYYY-MM-DD`) |
| `description`, `keywords`, `thumbnail_url` | The video's description, tags and best thumbnail |
| `channel_id`, `channel_url` | The channel, ready to join with other data |
| `channel_handle`, `channel_subscribers`, `channel_thumbnail_url` | The channel's @handle, subscriber count (as YouTube shows it, e.g. 8,680,000) and avatar |
| `video_length_seconds`, `is_live` | Length of the video itself, and whether it was a live stream |

Also in every row, under the names other Actors use: `url`, `status`, `selected_language`, `is_auto_generated`, `transcript_text`, `channel_username`, `thumbnail` and `transcript` (segments with an `end` time).

A run also writes `RUN_SUMMARY.json` to its key-value store: videos requested, delivered, charged, and one line per failed video with the reason.

#### Every field

| Field | What it holds |
|---|---|
| `video_id` | video ID |
| `video_url` | video URL |
| `title` | title |
| `channel` | channel |
| `language` | language |
| `is_generated` | is generated |
| `available_languages` | available languages |
| `duration_seconds` | duration seconds |
| `segment_count` | segment count |
| `word_count` | word count |
| `text` | text |
| `segments` | segments |
| `source` | source |
| `channel_id` | channel ID |
| `channel_url` | channel URL |
| `description` | description |
| `keywords` | keywords |
| `view_count` | view count |
| `video_length_seconds` | video length seconds |
| `thumbnail_url` | thumbnail URL |
| `is_live` | is live |
| `duration_human` | duration human |
| `hashtags` | hashtags |
| `is_private` | is private |
| `allow_ratings` | allow ratings |
| `playable_in_embed` | playable in embed |
| `caption_track_count` | caption track count |
| `is_translatable` | is translatable |
| `translation_languages` | translation languages |
| `fetched_at` | fetched at |
| `like_count` | like count |
| `comment_count` | comment count |
| `published_at` | published at |
| `channel_handle` | channel handle |
| `channel_subscribers` | channel subscribers |
| `channel_thumbnail_url` | channel thumbnail URL |
| `url` | URL |
| `status` | status |
| `selected_language` | selected language |
| `is_auto_generated` | is auto generated |
| `transcript_text` | transcript text |
| `channel_username` | channel username |
| `thumbnail` | thumbnail |
| `transcript` | transcript |

### How much does it cost?

**$0.0025 per transcript** — you pay only for videos that actually come back with a transcript.

| Videos | Cost |
|---:|---:|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |

- **Failed videos are never charged**: captions disabled, private, deleted or invalid links cost $0.
- **You set the ceiling**: `maxTotalChargeUsd` (default $1) stops the run before it spends more.
- Apify's free plan includes monthly platform credit, enough for hundreds of transcripts.
- **One transcript in every run of 2+ videos is free**, so you can check the output on your own videos.

For comparison, the most-used transcript Actors on the Store charge $0.00275–$0.01 per video.

### Use cases

- **LLM summarisation** in a SaaS product or internal tool.
- **RAG ingestion** — timestamped chunks that link back to the exact second.
- **AI agents** that need to "watch" a video before answering.
- **Search indexes** over video libraries.
- **Batch pipelines** in n8n, Make or Airflow.

### Use it from code (API)

Every Apify Actor is an API. Start a run and read the results with one call.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("om_kh/video-transcript-api").call(run_input={"videos": ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "jNQXAC9IVRw"], "language": "en", "includeSegments": True})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('om_kh/video-transcript-api').call({
    "videos": [
        "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
        "jNQXAC9IVRw"
    ],
    "language": "en",
    "includeSegments": true
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**One HTTP call (cURL)** — runs the Actor and returns the dataset in the same response:

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

### Integrations: n8n, Make, Zapier, Google Sheets

- **n8n** — the official *Apify* node, operation *Run Actor and get dataset*, Actor `om_kh/video-transcript-api`.
- **Make** — *Apify › Run an Actor*, then *Apify › Get Dataset Items*.
- **Zapier** — *Apify › Run Actor*; map the dataset items into your next step.
- **Google Sheets, webhooks, Slack** — add an integration from the *Integrations* tab of this Actor.
- **Schedules** — run it every hour or day from *Schedules* in Apify Console.

### Use it from an AI agent (MCP and x402)

Connect Claude Desktop, Cursor, VS Code or any MCP client to Apify's MCP server
at `https://mcp.apify.com` and add this Actor, `om_kh/video-transcript-api`, as a tool — the
agent passes the same JSON as the run input and gets the dataset back.

AI agents that pay with **x402** can run it too, without an Apify account: the
Actor charges only per result delivered, so an agent pays exactly for what it gets.

### Tips and limits

- **No captions, no transcript.** This Actor reads YouTube's own captions. A video with captions turned off returns a `NO_TRANSCRIPT` error for that video, is not charged, and the rest of the run continues.
- **Pick the language you want.** If your language is missing, check `available_languages` in the output and run again with one of them.
- **Big lists:** up to 1,000 videos per run; for a whole channel or playlist use [YouTube Channel Transcripts Scraper - Every Video to Text](https://apify.com/om_kh/youtube-channel-transcripts).
- **Speed:** videos are fetched 8 at a time; a typical video takes 1–3 seconds.

### FAQ

**Can I get SRT or VTT subtitle files?**
Yes. Set `outputFormats` to `["srt"]`, `["vtt"]` or both: each result then carries a ready-to-save `srt` / `vtt` string built from the timestamped captions. No extra charge.

**Is the output ready for RAG and LLMs?**
Yes. `outputFormats: ["chunks"]` adds `chunks`: consecutive captions merged into ~250-word pieces, each with `start` and `end` seconds, so you can embed them and cite the exact moment in the video.

**Can I translate a transcript?**
There is an experimental `translateTo` option that asks YouTube for its own machine translation. YouTube often refuses automated translation requests; when it does you still get the original transcript and a `translation_note` (and pay only the normal price). For reliable translation, send the `text` or `chunks` to your own translation model.

**Is it legal to scrape YouTube transcripts?**
This Actor only reads captions that YouTube shows publicly to any visitor. It does not log in and collects no personal data beyond the public channel name. You are responsible for how you use the text; check YouTube's terms and your local law, and consult a lawyer if unsure.

**Does it need a YouTube API key or cookies?**
No. There is no key, no login and nothing that expires.

**Can it transcribe videos that have no captions?**
No — it returns YouTube's existing captions (human or auto-generated), it does not run speech-to-text. Almost all spoken-word videos have auto-generated captions.

**Which languages are supported?**
Every language YouTube offers captions in. Set `language`, or leave it empty for English first.

**Can I get timestamps?**
Yes, `includeSegments` (on by default) returns every caption line with `start` and `duration` in seconds.

**Am I charged for videos that fail?**
Never. Only transcripts that are actually delivered are charged.

**Can I export to CSV or Excel?**
Yes, from the *Storage* tab of any run, or with `?format=csv` on the dataset API.

**Can my AI agent call it?**
Yes, via MCP (see above) or the plain HTTP API.

### Related Actors

- [YouTube Transcript Scraper - Full Text, Timestamps, Language](https://apify.com/om_kh/youtube-transcript-api)
- [YouTube Channel Transcripts Scraper - Every Video to Text](https://apify.com/om_kh/youtube-channel-transcripts)
- [YouTube Subtitles Scraper - Captions, Timestamps, Language](https://apify.com/om_kh/youtube-transcript-scraper)
- [YouTube Comments Scraper - Likes, Replies, Date, $0.40/1K](https://apify.com/om_kh/youtube-comments-scraper)
- [Google News Scraper - Headlines, Source, Date, API](https://apify.com/om_kh/google-news-scraper)

### Support

Found a bug or need a feature? Open an issue in the **Issues** tab of this Actor — every report gets an answer, usually within a day.

### All input fields

The main fields are described above; these are the others the form accepts:

- **`include_transcript_text`** (Include transcript text (alias)) — Accepted for compatibility: the plain `text` field is always included.

### Your feedback

Did this Actor save you time? A short review on the **Reviews** tab helps other people find it, and every review is read. Something missing or broken? Open an issue on the **Issues** tab: it is answered and fixed fast.

# Actor input Schema

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

Video URLs or IDs. Accepts watch links, youtu.be links, Shorts, embeds and bare 11-character IDs. Leave empty if you only pass channels.

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

Transcribe a whole channel: channel links, @handles or channel IDs. Newest videos first. Use it with or instead of the video list.

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

Newest first, 1 to 500. Default 10.

## `publishedAfter` (type: `string`):

Only channel videos uploaded on or after this date (YYYY-MM-DD).

## `publishedBefore` (type: `string`):

Only channel videos uploaded on or before this date (YYYY-MM-DD).

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

Two-letter language code (en, fr, es, de...). Human-written captions are always preferred over auto-generated ones. Leave empty for English, then the video's default.

## `includeSegments` (type: `boolean`):

Keep the per-line segments with start time and duration. Turn off for a plain-text transcript only.

## `includeStats` (type: `boolean`):

Add likes, comment count and upload date to every transcript (views, description, channel and thumbnail are always included). One extra lookup per video; turn off for the fastest runs.

## `translateTo` (type: `string`):

Experimental: asks YouTube for its own machine translation into this language code (fr, es, pt-BR...). YouTube often refuses automated translation requests; the original transcript is then returned with a translation_note, never a failed video.

## `outputFormats` (type: `array`):

Add ready-to-use formats to every transcript: 'srt' and 'vtt' subtitle files as text, and 'chunks' (about 250-word passages with start and end times, ready to embed for RAG).

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

YouTube blocks datacenter IPs, so this Actor routes through a proxy. Leave the default (Apify Proxy) unless you have your own.

## `maxTotalChargeUsd` (type: `number`):

Hard maximum amount that this run may charge. The run stops before exceeding it.

## `youtube_url` (type: `string`):

Same as one entry of `videos` (field name used by other YouTube transcript Actors).

## `videoUrl` (type: `string`):

Same as one entry of `videos`.

## `channel_url` (type: `string`):

Same as one entry of `channels`.

## `max_videos` (type: `integer`):

Same as `maxVideosPerChannel`.

## `start_date` (type: `string`):

Same as `publishedAfter` (YYYY-MM-DD).

## `end_date` (type: `string`):

Same as `publishedBefore` (YYYY-MM-DD).

## `targetLanguage` (type: `string`):

Same as `language`.

## `include_transcript_text` (type: `boolean`):

Accepted for compatibility: the plain `text` field is always included.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=aircAruvnKk",
    "https://youtu.be/dQw4w9WgXcQ"
  ],
  "maxVideosPerChannel": 10,
  "language": "",
  "includeSegments": true,
  "includeStats": true,
  "outputFormats": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "include_transcript_text": true
}
```

# Actor output Schema

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

A visual summary of delivery, charges, changes, and source issues.

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

Business-ready results in a sortable table. No JSON knowledge required.

## `csv` (type: `string`):

Results ready for spreadsheets, CRMs, and analytics tools.

## `excel` (type: `string`):

Results as an Excel workbook for non-technical teams.

## `runSummary` (type: `string`):

Machine-readable delivery, billing, and source diagnostics.

# 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=aircAruvnKk",
        "https://youtu.be/dQw4w9WgXcQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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