# YouTube Transcript Scraper (`fetch_cat/youtube-transcript-scraper`) Actor

Export public YouTube captions as transcript text and timestamped segments. Use video URLs or IDs, select a language, and download JSON or CSV for research and RAG.

- **URL**: https://apify.com/fetch_cat/youtube-transcript-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Videos, Social media, Developer tools
- **Features:** Limited permissions
- **Stats:** 31 total users, 9 monthly users, 97.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 1,000 transcript extracteds

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

Export existing public YouTube captions as transcript text and optional timestamped segments. Supply known video URLs or IDs and a preferred caption language for separate research, summaries, indexing or RAG. The Actor may request a YouTube-provided translation when supported, but does not transcribe missing audio with AI or run its own translation model.

### Quick start

Paste one public video URL, keep `maxVideos` small, and inspect the transcript results and **Per-video outcomes and input warnings** output before using the data.

```json
{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 1
}
```

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Open a saved example to inspect its inputs, then adjust the limits and filters for your own run. Examples are starting points. Source availability can change.

- [Extract YouTube transcripts for AI summaries](https://apify.com/fetch_cat/youtube-transcript-scraper/examples/extract-youtube-transcripts-for-ai-summaries) — Start with one video and timestamped captions for separate summarization.
- [Batch extract public captions from YouTube videos](https://apify.com/fetch_cat/youtube-transcript-scraper/examples/batch-extract-youtube-video-captions) — Review text-only captions from a bounded two-video list.
- [Extract Spanish YouTube captions](https://apify.com/fetch_cat/youtube-transcript-scraper/examples/extract-spanish-youtube-captions) — Prefer Spanish captions and check the actual language returned.

[View all ready-to-run examples](https://apify.com/fetch_cat/youtube-transcript-scraper/examples)

### What you get

Successful transcript rows include caption text, optional segment timing, the selected language and available metadata. Unavailable videos and completed caption documents with no usable text add no dataset row. Their reasons appear in the run summary instead.

If extraction fails, the run fails after preserving useful results from the rest of the bounded batch. Check the summary before treating a dataset as complete.

### Who is it for?

- **Research teams:** search and compare public talks, lectures, and interviews.
- **Content teams:** review webinar or demo captions and prepare source-linked summaries.
- **RAG builders:** chunk transcript text and retain video URLs and timestamps.
- **Media reviewers:** check language availability and caption quality before downstream use.

### How you can use the data

- **Prepare a source-linked caption review.** Use the existing dQw4w9WgXcQ video with one-video cap, English preference and timestamps. Keep the video URL and segment start beside any downstream summary, verifying quotations against the original rather than trusting automated captions as exact speech.
- **Build a bounded retrieval index.** Send only successful transcriptText and segments to your own document or vector store. Preserve videoId, returned language and timing when available, and use the run summary to identify videos that did not yield text.
- **Review language availability explicitly.** Request the documented Spanish or French language option for a known video, then inspect the returned language. A translated or fallback track can differ from the request and does not establish that the original speaker used that language.
- **Compare your own recurring exports.** Schedule a fixed known-video list and store results in your destination. Channel discovery, caption change detection, subtitle-file creation and notifications are separate downstream steps rather than built-in complete channel monitoring.

### Input settings

| Setting | JSON key | Type / default | What it does |
| --- | --- | --- | --- |
| YouTube video URLs | `videoUrls` | array / not set | Public YouTube watch, shorts, live, embed, or youtu.be URLs to extract transcripts from. |
| Video IDs | `videoIds` | array / `[]` | Optional raw 11-character YouTube video IDs. Use this instead of URLs if you already have IDs. |
| Preferred caption language | `language` | string / `"en"` | Preferred caption language, such as en, es, de, or fr. The Actor may request a YouTube-provided translation when supported, then fall back to another available track. Check the returned language. |
| Include timestamps | `includeTimestamps` | boolean / `true` | Include start and duration values for every transcript segment. |
| Include video metadata | `includeMetadata` | boolean / `true` | Include title, channel name, duration, and thumbnail URL when YouTube exposes them publicly. |
| Maximum videos | `maxVideos` | integer / `5` | Maximum number of videos to process in this run. Keep this low for the first test run. Minimum 1. Maximum 500. |
| Connection | `connectionMode` | string / `"automatic"` | Choose Direct or Automatic. See the field help for fallback costs and advanced overrides. |

Use either video URLs or raw IDs. Neither input mode discovers all videos on a channel. The returned `language` can differ from your preference when another available caption track is selected.

### Output data

Illustrative shortened success record. The caption text below is not taken from the linked video. Optional metadata is omitted in this example.

```json
{
  "videoId": "dQw4w9WgXcQ",
  "videoUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "language": "en",
  "isAutoGenerated": false,
  "transcriptText": "Illustrative caption text.",
  "segments": [
    {
      "start": 0,
      "duration": 2.1,
      "text": "Illustrative caption text."
    }
  ],
  "captionsAvailable": true
}
```

| JSON key | Type | Meaning |
| --- | --- | --- |
| `videoId` | string | YouTube video identifier. |
| `videoUrl` | string | Canonical public watch URL. |
| `title` | string | Public title when metadata is enabled and available. Otherwise omitted. |
| `channelName` | string | Public channel name when enabled and available. Otherwise omitted. |
| `language` | string | Language of the selected caption track. May differ from the requested language. |
| `isAutoGenerated` | boolean | Whether the selected track is marked as auto-generated. Omitted when unavailable. |
| `transcriptText` | string | Combined caption text when extraction succeeds. |
| `segments` | array | Caption text segments. Timing properties are included only when requested. |
| `duration` | number | Video length in seconds when metadata is enabled and available. |
| `thumbnailUrl` | string | Public thumbnail URL when metadata is enabled and available. |
| `captionsAvailable` | boolean | Whether public captions were available for this result. Check error and transcriptText before consuming it. |
| `error` | string | Diagnostic information when present in older results. Current per-video outcomes are in the run summary. |

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

The `start` event is charged once for a run with valid targets. The `transcript` event applies to saved transcript results. Unavailable or empty results have no transcript-result charge, but the start charge and applicable platform usage can still apply.

Extraction stops when no further transcripts fit the run's charge limit. Check the summary for any targets not saved because of that limit.

The one-time start charge remains **$0.005 per run**. A transcript price increase is scheduled for **20 November 2026 at 00:47:45.647 UTC**; it is not effective before that time. The source configuration contains the scheduled rates below, not a second price change.

| Customer plan | Current price per transcript (before the effective time) | Scheduled price per transcript |
| --- | --- | --- |
| Free | $0.00015338 | $0.00095 |
| Bronze | $0.00013338 | $0.00068 |
| Silver | $0.00010403 | $0.00062 |
| Gold / Business (including Platinum and Diamond) | Gold $0.000080027; Platinum $0.000053351; Diamond $0.000037346 | $0.00057 |

The scheduled Business price is shared by Gold, Platinum and Diamond. For example, 1,000 saved transcripts plus one start charge will cost $0.955 on Free, $0.685 on Bronze, $0.625 on Silver or $0.575 on Business at the scheduled rates, excluding any separately applicable platform usage.

See the [live Pricing tab](https://apify.com/fetch_cat/youtube-transcript-scraper/pricing) for the rates effective for your account. Check the cost shown before scaling a run. Any applicable platform usage is shown by Apify separately.

### Tips for best results

- **Inspect the run summary.** It identifies unavailable, failed or budget-limited targets separately from usable transcripts.
- **Verify important quotations.** Automated captions can misrecognize words and speaker meaning.
- **Keep the returned language.** Requested language, translated tracks and fallback tracks are not interchangeable.
- **Retain timestamped source references.** Use segment starts for separate summaries, and create any SRT or VTT files downstream.
- **Bound the video list deliberately.** Start with a few videos and inspect their results before increasing `maxVideos`.

### Limits and caveats

- **Check availability:** private, deleted, members-only, region-restricted, or captionless videos may not yield transcript text.
- **Check accuracy:** automated captions can contain recognition errors. Verify quotes against the original video.
- **Control batch size:** use `maxVideos` to cap work, especially when proxy fallback is needed.
- **Handle partial results:** a failed run can still contain useful saved transcripts. The summary identifies the failed targets.
- **Keep requests bounded:** processing has a five-minute total budget that does not renew on restart. Oversized responses or transcripts are rejected rather than silently truncated.
- **Respect content rights:** public accessibility does not grant redistribution or model-training rights. Use captions only where your processing is permitted.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

Save the Quick start JSON as input.json. This starts an asynchronous run. Use the returned run ID to check completion and defaultDatasetId to retrieve results.

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~youtube-transcript-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  --data-binary @input.json
```

#### Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/youtube-transcript-scraper').call({
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 1
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import json
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = json.loads('''{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 1
}''')
run = client.actor("fetch_cat/youtube-transcript-scraper").call(run_input=run_input)
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

### MCP and AI agents

You can ask your AI assistant to collect data with **YouTube Transcript Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **YouTube Transcript Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/youtube-transcript-scraper"
    }
  }
}
```

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **YouTube Transcript Scraper** by Fetch Cat, or give it the identifier `fetch_cat/youtube-transcript-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Get the available English captions for this public YouTube talk, with timestamps. Summarize its main points and link each quotation back to the video.”
- “Retrieve captions for this video with Spanish preferred. Tell me which language was actually returned before preparing a separate summary.”
- “Collect text-only captions for these two public YouTube videos. Keep unavailable results separate so I can add only usable transcripts to my research index.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/youtube-transcript-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Does it work without YouTube cookies?

It is designed for public videos and caption tracks without a YouTube login. Apify API and MCP access still require Apify authentication.

#### Why is transcript text missing?

Open **Per-video outcomes and input warnings** in the run's output. Supported unavailable or empty results have no dataset row. Blocking, unrecognized responses or failed extraction make the run fail while preserving any useful transcripts already saved.

#### Can I request Spanish or French captions?

Yes, set `language` to `es` or `fr`. Check the returned language because the Actor can fall back to another available track.

#### Does it export SRT or VTT files?

This Actor returns a dataset with text and optional segments. Use the segment timing to create subtitle files downstream. It does not promise native SRT/VTT output.

### Related Actors

#### More YouTube scrapers

- [YouTube Channel Email Scraper](https://apify.com/fetch_cat/youtube-channel-email-scraper) — Collect channel contact statuses and explicitly published public email evidence, without guessing addresses.
- [YouTube Comments Scraper](https://apify.com/fetch_cat/youtube-comments-scraper) — Collect available public YouTube video comments and exposed replies.
- [YouTube Search Results Scraper](https://apify.com/fetch_cat/youtube-search-results-scraper) — Collect public YouTube search-result metadata for supported video, channel or playlist searches.
- [YouTube Channel Details Scraper](https://apify.com/fetch_cat/youtube-channel-details-scraper) — Collect public YouTube channel descriptions, identifiers and available audience counts.
- [YouTube Video Details Scraper](https://apify.com/fetch_cat/youtube-video-details-scraper) — Collect public YouTube video metadata and available engagement from known video URLs.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/youtube-transcript-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/youtube-transcript-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

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

# Actor input Schema

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

Public YouTube watch, Shorts, live, embed or youtu.be URLs. Use this list or Video IDs. Unsupported hosts, malformed IDs and credential-bearing URLs are skipped with input warnings while valid targets are retained. If no usable targets remain, the run finishes with a warning and no extraction or start charge.

## `videoIds` (type: `array`):

Optional raw 11-character YouTube video IDs. Use this instead of URLs if you already have IDs.

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

Preferred caption language code, such as en, es, de, or fr. When supported, YouTube-provided translation may be requested. Another available track can be used if the preferred track fails. Check the returned language.

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

Include start and duration values for every transcript segment.

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

Include title, channel name, duration, and thumbnail URL when YouTube exposes them publicly.

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

Maximum unique valid videos selected, from 1 to 500. The default is 5. Processing is also bounded by the original five-minute run budget, response/output size safeguards and remaining transcript-charge capacity. Restarts do not renew the time budget. Check the run summary for targets not processed or saved.

## `connectionMode` (type: `string`):

Automatic preserves the existing strategy: direct requests first, with Apify Residential Proxy fallback only after an eligible blocking response. Proxy usage can add cost and does not guarantee captions. Direct never enables a proxy fallback. Explicit legacy proxyConfiguration settings take precedence over this selector, including its default and prefill. Each video has at most eight top-level attempts, each with at most ten redirects, plus bounded SDK proxy access checks. All work shares the original run deadline.

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

Optional advanced override. Existing saved/API configurations remain supported and take precedence over Connection. Requests still start directly. Configured managed groups or customer proxy URLs are used only for the existing classified fallback. An explicit useApifyProxy: false without proxyUrls prevents fallback, even when Automatic is selected. To use the simple selector, leave this field unset. No proxy credentials are logged.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "videoIds": [
    "dQw4w9WgXcQ"
  ],
  "language": "en",
  "includeTimestamps": true,
  "includeMetadata": true,
  "maxVideos": 5,
  "connectionMode": "automatic"
}
```

# Actor output Schema

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

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "videoUrls": [
        {
            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        }
    ],
    "videoIds": [
        "dQw4w9WgXcQ"
    ],
    "language": "en",
    "connectionMode": "automatic"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "videoUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
    "videoIds": ["dQw4w9WgXcQ"],
    "language": "en",
    "connectionMode": "automatic",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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 '{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "videoIds": [
    "dQw4w9WgXcQ"
  ],
  "language": "en",
  "connectionMode": "automatic"
}' |
apify call fetch_cat/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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