# YouTube Transcript Scraper | $1/1K · SRT & VTT (`technicaldost/youtube-transcript-scraper-plus`) Actor

Extract YouTube transcripts, captions and subtitles in bulk. Language selection, timestamps, SRT/VTT downloads and AI text chunks. $1 per 1,000 successful transcripts; no API key.

- **URL**: https://apify.com/technicaldost/youtube-transcript-scraper-plus.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** Videos, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 successful 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 Transcript Scraper Plus

Extract **YouTube transcripts, captions and subtitles in bulk** from public videos and Shorts. Get readable text, timestamped segments, downloadable SRT and WebVTT files, and timestamped chunks for search or AI workflows. No YouTube API key or account login is required.

**Price: $1 per 1,000 successful transcripts**, with a $0.00005 Actor-start fee. Failed videos and duplicate inputs do not create paid results.

### Quick start

1. Click **Try for free** and enter video links or IDs in **YouTube videos or IDs**.
2. Choose your preferred caption languages, or keep English with fallback enabled.
3. Run the Actor. Open **Transcripts** for text and metadata, **Subtitle files** for downloads, and **Run report** for any unavailable videos.

The default example is a short public video with captions. Datacenter proxies and session rotation are enabled to improve access from cloud servers. You can disable proxies or supply your own proxy configuration.

### Features

- Watch URLs, Shorts, live video URLs, embed URLs, youtu.be links and raw video IDs.
- Deduplication by video ID before any requests or billing.
- Preferred languages in priority order, optional fallback, and preference for human captions.
- Full transcript text, segment timestamps, language details, title, channel and word count.
- SRT and WebVTT downloads in the run key-value store.
- Configurable text chunks with start and end times for AI and search pipelines.
- Bounded concurrency, request timeouts, multiple YouTube player clients and rotating proxy sessions.
- Per-video error details in `REPORT` and `ERRORS`; failed videos are not added to the paid dataset.
- Incremental delivery and state persistence for graceful aborts and resumed runs.

### Input

```json
{
  "videoUrls": ["jNQXAC9IVRw", "https://youtu.be/jNQXAC9IVRw"],
  "languages": ["en", "hi"],
  "allowLanguageFallback": true,
  "preferManual": true,
  "includeTimestamps": true,
  "subtitleFormat": "both",
  "chunkSeconds": 60,
  "maxVideos": 100,
  "maxConcurrency": 3
}
```

The two example entries refer to the same video, so it is processed once. `startUrls` is also accepted, with strings or objects containing `url`. `timestamps: false` is accepted for compatibility.

Use `languages` to request existing caption tracks. This release does not perform machine translation.

| Input | Default | What it controls |
| --- | --- | --- |
| `videoUrls` | Form example | Video URLs or IDs; at least one video is needed |
| `startUrls` | Empty | Compatibility input; strings or `{ "url": "..." }` objects |
| `languages` | `["en"]` | Caption languages in priority order |
| `allowLanguageFallback` | `true` | Accept another language if preferred captions are absent |
| `preferManual` | `true` | Prefer human captions within the chosen language |
| `includeTimestamps` | `true` | Include individual caption segments |
| `subtitleFormat` | `"both"` | `srt`, `vtt`, `both`, or `none` |
| `chunkSeconds` | `60` | Time window for text chunks; `0` disables them |
| `maxVideos` | `100` | Process up to 10,000 unique videos per run |
| `maxConcurrency` | `3` | Parallel video jobs, from 1 to 10 |
| `proxyConfiguration` | Datacenter proxies | Configure Apify proxies or custom proxy URLs |

### Results

Each successful video produces one dataset item. `transcriptText` contains the full text. `segments` contains `start`, `duration`, `end` and `text`. `chunks` groups the same text into time windows. `subtitleFiles` contains download URLs.

Export the dataset as JSON, CSV, Excel or other Apify-supported formats. Read the `REPORT` key-value-store record for counts, duplicates, spending-limit status and failures. A run with zero delivered transcripts fails clearly.

The output schema describes all fields for API and MCP users. Caption times and chunk times are measured in seconds. `requestedLanguages`, `language` and `languageFallbackUsed` make language fallback visible.

### Use cases

- Feed timestamped video text into retrieval-augmented generation (RAG) and semantic search.
- Collect lecture and tutorial captions for research and study.
- Build accessibility and subtitle-editing workflows with SRT or WebVTT files.
- Analyze caption text for content research, SEO and repurposing.
- Prepare existing caption text for downstream summarization or NLP tools.

The Actor supplies caption text and metadata. Summarization and sentiment analysis are downstream workflows, not built-in output features.

### Pricing

**$1 per 1,000 successful transcripts**, plus **$0.00005 per Actor start** at the supported memory settings. Subtitle files and chunks are part of the same result, with no extra output charges. Failed videos and duplicate inputs do not create paid dataset items. Check the live Pricing tab for the active price. Your own external proxy provider may charge separately if you supply custom proxy URLs.

| Apify plan | Price per 1,000 transcripts |
| --- | ---: |
| Free | $1.00 |
| Bronze | $0.95 |
| Silver | $0.90 |
| Gold, Platinum, Diamond | $0.85 |

At the base price, 100 delivered transcripts in one run cost **$0.10005**. Ten delivered transcripts cost **$0.01005**. Paid-plan discounts reduce these amounts. Setting `maxVideos` limits unique videos, and Apify's maximum-charge setting limits the run's bill. The minimum maximum-charge setting is $0.00105, enough for one base-price result and the start fee.

### Caption availability

This Actor retrieves existing captions; it does not transcribe audio. Private, deleted, age-restricted, region-restricted and captionless videos may be unavailable. YouTube may block cloud IPs or return empty caption responses. Rotating proxies can improve access but do not guarantee it. Language fallback is reported explicitly in each result.

No YouTube API key or account cookies are required. Only submit public videos you are authorized to process.

### API

Use the Apify API or a saved task to run `technicaldost/youtube-transcript-scraper-plus`. Input and results are compatible with Apify integrations, webhooks and dataset export tools.

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('technicaldost/youtube-transcript-scraper-plus').call({
  videoUrls: ['jNQXAC9IVRw'],
  languages: ['en'],
  subtitleFormat: 'both'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

For n8n, Make or Zapier, pass the same JSON input to the Apify integration and read the default dataset after the run finishes. For AI agents, use the Apify MCP server to discover and invoke the Actor; the input, dataset and output schemas describe the supported workflow.

### Troubleshooting and FAQ

**Why was a video not returned?** Check `REPORT` or `ERRORS`. The video may lack captions, require login, be unavailable, or have blocked the request. Partial batches preserve successful results.

**Does this transcribe videos without captions?** No. It retrieves existing manual or automatic captions, rather than performing speech recognition.

**Does it support every language?** It supports caption tracks exposed by YouTube. Disable fallback if you require your preferred language family. Machine translation is not included.

**Can I enter a channel or playlist?** Enter individual video URLs or IDs. Channel and playlist discovery are not included.

**Why is the transcript in another language?** With language fallback enabled, the Actor may choose another available track. The actual language is always reported. Set `allowLanguageFallback` to `false` to require your preferred languages.

**How do I report an issue?** Open the Actor's Issues tab with the run URL, video ID and requested language. Do not include account tokens or proxy credentials.

### Local development

Use Node.js 22 or newer: `npm ci`, `npm test`, then `apify run` with your local input. Deploy with `apify push`.

# Actor input Schema

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

Watch, Shorts, embed, youtu.be URLs or 11-character video IDs. Duplicate videos are processed once.

## `startUrls` (type: `array`):

Optional compatibility with startUrls: strings or objects containing url.

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

Caption language codes in priority order, such as en, hi, es.

## `allowLanguageFallback` (type: `boolean`):

Use another caption language when none of the preferred languages is available.

## `preferManual` (type: `boolean`):

Prefer manual captions within each language.

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

Include start, duration, end and text per segment.

## `subtitleFormat` (type: `string`):

Save downloadable subtitle files in the run key-value store.

## `chunkSeconds` (type: `integer`):

Group cues into timestamped text chunks. Zero disables chunking.

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

Limit videos per run.

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

Limit parallel requests.

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

Datacenter proxies are enabled by default with session rotation. Custom proxies are optional. Residential proxies can increase operating costs.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=jNQXAC9IVRw"
  ],
  "languages": [
    "en"
  ],
  "allowLanguageFallback": true,
  "preferManual": true,
  "includeTimestamps": true,
  "subtitleFormat": "both",
  "chunkSeconds": 60,
  "maxVideos": 100,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per successful video with text, language, metadata, timestamps and AI text chunks.

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

Downloadable SRT and WebVTT subtitle files.

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

Requested, selected, successful, failed and deduplicated counts, plus per-video errors.

# 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=jNQXAC9IVRw"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/youtube-transcript-scraper-plus").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=jNQXAC9IVRw"] }

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/youtube-transcript-scraper-plus").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=jNQXAC9IVRw"
  ]
}' |
apify call technicaldost/youtube-transcript-scraper-plus --silent --output-dataset

```

## MCP server setup

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

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/XVqJ9EmBSjNWJ1oDz/builds/as0q37GNCVblNovTR/openapi.json