# YouTube Transcript Scraper 💰 From $0.01 | No Browser (`ahmed_jasarevic/youtube-subtitle-scraper-fast`) Actor

Extract YouTube transcripts and subtitles with full video metadata — fast and without a browser. Bulk-process videos, shorts and playlists, get SRT/VTT files, and never pay for videos without captions.

- **URL**: https://apify.com/ahmed_jasarevic/youtube-subtitle-scraper-fast.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 results

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 Subtitle Scraper — Fast & Cheap

Extract **YouTube transcripts and subtitles** (manual *and* auto-generated) together with full video metadata — **without a browser**. One video takes about **1 second** and a fraction of a cent of compute, because every request is a plain HTTP call to YouTube's own data.

This is a **YouTube transcript scraper built for scale**: pipe transcripts into LLM/RAG pipelines, content repurposing tools, accessibility workflows and bulk research — with **SRT/VTT export** and **no browser, no CAPTCHA, no wasted proxy spend**.

### Use Cases

- **LLM & RAG pipelines** — turn videos into text to summarize, quote, embed or index
- **Content repurposing** — video → blog post → social thread, automated on a schedule
- **Bulk transcript research** — transcribe a whole channel, playlist or corpus of talks for analysis
- **Accessibility & subtitles** — generate SRT/VTT files for videos that lack captions, in the languages you need
- **Sentiment & topic analysis** — analyze transcripts at scale with your own NLP models
- **SEO & content mining** — mine keywords and topics from competitors' videos

### How It Works

Every request is a **plain HTTP call — no headless Chromium**, so the actor avoids the 5–15 seconds per video that browser-based subtitle scrapers pay. YouTube blocks cloud IPs, so the actor automatically uses the **Apify residential proxy** (a few hundred KB per video) and rotates sessions on rate limits. Extraction runs in **parallel** (default 10 concurrent videos, up to 20).

Subtitle track selection is graceful: it requests your chosen language, then **falls back to any manual track, then any auto-generated track**. Videos without subtitles (live streams, disabled captions) are reported as error items and **never charged**.

### Extract YouTube Transcripts And Subtitles Without The Official API

YouTube's official Data API **caption endpoints only work for videos you own** — they cannot fetch captions for third-party videos, and they carry quotas. This actor reads the same transcript data the YouTube page uses, at scale, with no OAuth and no quota management on your side.

- **Input flexibility** — `watch`, `shorts`, `youtu.be`, `/embed/`, `/live/` URLs and even bare 11-character video IDs
- **Playlists** — switch on playlist expansion to process every video in a playlist (with a safety cap)
- **Formats** — plain transcript text, timestamped transcript, and ready-to-use **SRT** and **VTT** subtitle files
- **Metadata** — title, channel, views, length, publish date and category, alongside each transcript

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | Yes | one sample video | Video URLs (watch, shorts, youtu.be) — or playlist URLs when *Expand playlists* is on |
| `language` | string | No | `en` | Transcript language. Falls back to any manual track, then auto-generated. `any` = best available |
| `timestamps` | boolean | No | `false` | Prefix each transcript line with `[h:mm:ss]` and include per-segment data |
| `includeSrt` | boolean | No | `false` | Add a ready-to-use SRT subtitle file as a text field |
| `includeVtt` | boolean | No | `false` | Add a ready-to-use WebVTT subtitle file as a text field |
| `expandPlaylists` | boolean | No | `false` | Treat playlist URLs as a list of videos and process every video |
| `maxPlaylistVideos` | integer | No | `100` | Safety cap when expanding playlists |
| `maxVideos` | integer | No | `0` | Hard cap on total videos in a run. `0` = no cap |
| `concurrency` | integer | No | `10` | Videos extracted in parallel (1–20) |
| `proxyConfiguration` | object | No | Apify residential proxy | Defaults to residential because YouTube blocks cloud IPs |

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.youtube.com/watch?v=SieELGaJV8k" },
    { "url": "https://youtu.be/dQw4w9WgXcQ" }
  ],
  "language": "en",
  "timestamps": false,
  "includeSrt": false,
  "concurrency": 10
}
```

### Example Output

| Field | Description |
|---|---|
| `url`, `video_id` | Canonical video URL and ID |
| `title`, `channel_name`, `channel_id` | Video and channel identity |
| `views`, `length_seconds`, `publish_date`, `category` | Raw metadata as reported by YouTube |
| `transcript_language`, `transcript_language_code`, `is_auto_generated` | Which subtitle track was used |
| `segment_count`, `transcript_chars` | Size of the transcript |
| `transcript` | Full transcript text (with `[h:mm:ss]` timestamps when enabled) |
| `segments` | Per-line `{start, duration, text}` — only when *Timestamped transcript* is on |
| `srt`, `vtt` | Ready-to-use subtitle files — optional |
| `error` | Failure reason — only for videos that could not be processed |

```json
{
  "url": "https://www.youtube.com/watch?v=SieELGaJV8k",
  "video_id": "SieELGaJV8k",
  "title": "Example video",
  "channel_name": "Example Channel",
  "views": 123456,
  "length_seconds": 612,
  "transcript_language": "English",
  "is_auto_generated": false,
  "segment_count": 210,
  "transcript_chars": 8421,
  "transcript": "Welcome back to the channel..."
}
```

### Pricing

Pay-per-event, **billed per successful video — failed videos are never charged**:

| Event | Price | When |
|---|---|---|
| `result` | $0.01 | One extracted transcript with metadata |
| `long-video` | $0.02 | Add-on, charged for videos longer than 20 minutes |
| `apify-actor-start` | $0.00005 | Per GB of memory when the run starts (512 MB = $0.00005) |

Example: a 10-video batch of regular videos costs $0.10; a single 3-hour podcast costs $0.03. For comparison, a 10-minute video with a browser-based YouTube scraper on the Store commonly costs several times more in proxy + compute.

### Integrations And Automation

- **Apify API** — call the actor from your app and read the dataset.
- **Webhooks** — kick off downstream summarization or indexing when a run finishes.
- **Scheduled runs** — monitor channels/playlists **daily** or **weekly** to capture new uploads automatically.
- **Zapier / Make / n8n** — feed new transcripts into Notion, Google Sheets, Airtable or a vector store.
- **Export** — JSON, CSV, Excel; transcript text stays clean and ready for LLMs.

### Related Actors

- [YouTube Scraper](https://apify.com/streamers/youtube-scraper) — the largest YouTube actor for channel, video and comment metadata; pair with this one for transcripts
- [YouTube Comments Scraper](https://apify.com/streamers/youtube-comments-scraper) — audience sentiment to complement your transcript analysis
- [TikTok Scraper](https://apify.com/clockworks/tiktok-scraper) — short-form video data for cross-platform content research
- [Instagram Scraper](https://apify.com/apify/instagram-scraper) — multi-platform content dataset building
- [Website Content Crawler](https://apify.com/apify/website-content-crawler) — extend your RAG corpus from video transcripts to full web pages

### FAQ

#### Does YouTube have an official transcript API?

YouTube's official Data API **caption endpoints only work for videos you own**, so they cannot fetch captions for third-party videos. For everyone else, the options are brittle scraping of YouTube's internal endpoints or a hosted service — this actor does that work reliably, at scale, charging only for successful videos.

#### Why is this actor faster and cheaper than other YouTube transcript scrapers?

It uses **plain HTTP, not a headless browser**. Browser-based subtitle scrapers pay for proxy traffic and burn 5–15 seconds per video; this actor does not, so it is faster and dramatically cheaper per video.

#### Which formats can I get?

Plain transcript text, timestamped transcript, and ready-to-use **SRT** and **VTT** subtitle files — all from the same run.

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

Yes. Turn on *Expand playlists* to process every video in a playlist (with `maxPlaylistVideos` as a safety cap); feed a list of video IDs to process a channel's videos in bulk.

#### What happens to videos with no captions?

They are reported as **error items** and are **never charged**. Live streams and videos with disabled captions typically have no subtitle track available.

#### Does auto-generated text work?

Yes. Auto-generated subtitles exist for most videos, so coverage is very high. The track used is reported in `is_auto_generated`.

#### How do I use this for an LLM / RAG pipeline?

Set `language` to your language and read the `transcript` field (or `segments` for timestamped data), then chunk and embed it in your vector store. Schedule the actor to keep the corpus fresh.

#### Can I export transcripts to CSV or JSON?

Yes — JSON, CSV, Excel and more from the dataset tab or the API.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by YouTube or Google**. It accesses only **publicly available** subtitle/transcript data and video metadata; it does not bypass login and does not solve CAPTCHAs.

You are responsible for complying with YouTube's Terms of Service and all applicable laws, including **copyright** rules — transcripts are derived from creators' content, so respect the rights of video owners when you store, republish or train on them.

### For AI Agents & LLM Apps

**Purpose:** returns YouTube transcripts/subtitles plus video metadata as structured JSON, one item per successfully processed video, for RAG, summarization and bulk content analysis.

**Minimal working input:**

```json
{ "startUrls": [{ "url": "https://www.youtube.com/watch?v=SieELGaJV8k" }] }
```

**Variant — timestamped transcript with subtitle files:**

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/watch?v=SieELGaJV8k" }],
  "language": "en",
  "timestamps": true,
  "includeSrt": true,
  "includeVtt": true
}
```

**Variant — expand a playlist:**

```json
{
  "startUrls": [{ "url": "https://www.youtube.com/playlist?list=PLxxxxxxxx" }],
  "expandPlaylists": true,
  "maxPlaylistVideos": 50,
  "concurrency": 10
}
```

**Output fields:** `url`, `video_id`, `title`, `channel_name`, `channel_id`, `views`, `length_seconds`, `publish_date`, `category`, `transcript_language`, `transcript_language_code`, `is_auto_generated`, `segment_count`, `transcript_chars`, `transcript`, `segments`, `srt`, `vtt`, `error`.

**Behaviors an agent should know:**

- `startUrls` is **required** and accepts watch/shorts/youtu.be/embed/live URLs or bare 11-char video IDs.
- `language` defaults to `en`; if unavailable it **falls back to any manual track, then auto-generated**. Use `any` for best-available.
- `segments` is only populated when `timestamps` is `true`; `srt` only when `includeSrt` is `true`; `vtt` only when `includeVtt` is `true`.
- Playlist URLs are only expanded when `expandPlaylists` is `true` (otherwise treated as a single target); `maxPlaylistVideos` caps the expansion.
- `maxVideos` is a hard total cap; `0` means no cap. Default `concurrency` is 10 (max 20).
- Videos without captions return an `error` item and are **never billed**.
- Billing is **pay-per-event**: `result` $0.01 per successful transcript, `long-video` +$0.02 for videos over 20 minutes, plus a tiny per-GB start charge.

### SEO Keywords

youtube transcript scraper, youtube transcript api, youtube subtitles scraper, youtube captions downloader, extract youtube transcript, bulk youtube transcript, youtube transcript bulk download, youtube to text, youtube srt, youtube vtt, youtube subtitle downloader, youtube transcript for llm, youtube transcript for rag, transcript api alternative, cheap youtube transcript api, youtube transcript without api key, youtube channel transcript, youtube playlist transcript, auto generated captions scraper, transcript extraction, youtube subtitle generator, no browser youtube scraper, batch youtube transcripts, youtube content research, video to text

# Actor input Schema

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

Video URLs (watch, shorts, youtu.be), or playlist URLs when 'Expand playlists' is on.

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

Language of the transcript/subtitles. If the chosen language is not available for a video, the Actor automatically falls back to any manual track, then to auto-generated captions.

## `timestamps` (type: `boolean`):

Prefix every transcript line with its \[h:mm:ss] timestamp and include per-segment data.

## `includeSrt` (type: `boolean`):

Add a ready-to-use SRT subtitle file as a text field.

## `includeVtt` (type: `boolean`):

Add a ready-to-use WebVTT subtitle file as a text field.

## `expandPlaylists` (type: `boolean`):

Treat playlist URLs as a list of videos and process every video in them.

## `maxPlaylistVideos` (type: `integer`):

Safety cap when expanding playlists.

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

Hard cap on the total number of videos processed in one run. 0 = no cap.

## `concurrency` (type: `integer`):

How many videos are extracted in parallel (1-20).

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

Defaults to the Apify residential proxy, because YouTube blocks requests coming from cloud IPs. Traffic is only a few hundred KB per video. Change this only if you want to use your own proxy setup.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=SieELGaJV8k"
    }
  ],
  "language": "en",
  "timestamps": false,
  "includeSrt": false,
  "includeVtt": false,
  "expandPlaylists": false,
  "maxPlaylistVideos": 100,
  "maxVideos": 0,
  "concurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Video metadata and transcripts for every processed video. Failed videos appear with an 'error' field instead of transcript data.

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

Transcript text and optional SRT/VTT subtitle exports for every processed video.

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

Only videos that failed (captions disabled, private/removed video, rate limit).

# 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 = {
    "startUrls": [
        {
            "url": "https://www.youtube.com/watch?v=SieELGaJV8k"
        }
    ],
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/youtube-subtitle-scraper-fast").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 = {
    "startUrls": [{ "url": "https://www.youtube.com/watch?v=SieELGaJV8k" }],
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/youtube-subtitle-scraper-fast").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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=SieELGaJV8k"
    }
  ],
  "language": "en"
}' |
apify call ahmed_jasarevic/youtube-subtitle-scraper-fast --silent --output-dataset

```

## MCP server setup

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

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/2FhJrBvkqpmJfFNuv/builds/ZGN85fW2sXbw65hNK/openapi.json