# YouTube Transcript Generator - Bulk Captions & Subtitles (`convertfleetdotonline/youtube-transcript-scraper`) Actor

YouTube transcript generator and extractor - pull full transcripts, captions and SRT subtitles in bulk, with timestamps, in 100+ languages. No API key, no quota. Paste many YouTube URLs at once.

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

## Pricing

$8.00 / 1,000 transcript scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## YouTube Transcript Generator – Extract Bulk Captions & Subtitles, No API Key

**A YouTube transcript generator and extractor that pulls the full transcript of any YouTube video in seconds — in bulk, in 100+ languages, with timestamps, clean text, and ready-to-use SRT subtitles.** Turn any YouTube video to transcript with no API key, no daily quota and no login. Paste one URL or a thousand and get back clean, structured transcripts you can drop straight into ChatGPT, a blog post, a database, or your own AI pipeline.

### ⚡ At a glance

| | |
|---|---|
| **What you give it** | One or more YouTube video URLs (watch, `youtu.be`, Shorts, live, embed — or a bare video ID) |
| **What you get back** | Full plain-text transcript + timestamped segments + optional SRT, plus video metadata |
| **Bulk input** | ✅ Unlimited URLs per run — processed in one go |
| **Languages** | ✅ 100+ — human-made subtitles **and** auto-generated captions, with optional auto-translation |
| **API key required** | ❌ None — no YouTube Data API, no OAuth, no quota |
| **Output formats** | JSON, CSV, Excel, plain text, SRT |
| **Speed** | ~1–3 seconds per video |
| **Best for** | AI/LLM context, content repurposing, subtitles, SEO, research |

### What this YouTube Transcript Scraper does

Give it a list of YouTube URLs and it returns a clean, structured transcript for each one — the **complete spoken text**, plus per-line timestamps, the caption language, and the source video's metadata (title, channel, duration, views, upload date, thumbnail). It reads both **human-uploaded subtitles** and YouTube's **auto-generated captions**, and can **translate** the transcript into another language on the fly.

It works **without the YouTube Data API**, so you are never subject to the official 10,000-units/day quota. No API key. No OAuth. No sign-in.

### Why this scraper beats the rest

Most YouTube transcript tools make you submit videos **one at a time**, force you to pick the exact caption language up front (and fail if you guess wrong), and hand back a bare list of `{start, text}` fragments. This actor is built to be the one you keep:

- 🚀 **True bulk mode** — pass an array of URLs and scrape them all in a single run. No looping, no one-by-one.
- 🧠 **Smart language fallback** — list your preferred languages in order; it returns the first that exists and **tells you which it used**. If none match, it gracefully falls back to the video's original captions instead of failing.
- 📝 **Three transcript shapes at once** — clean paragraph **text** (perfect for LLMs), **timestamped segments**, and a ready-to-import **SRT** subtitle file.
- 🌍 **100+ languages + live translation** — pull captions in the original language or auto-translate to any supported language with one field.
- 🏷️ **Rich metadata included** — title, channel, duration, views, upload date and thumbnail come with every transcript, so you don't need a second scraper.
- 📊 **Word counts & stats** — `wordCount`, `characterCount`, `segmentCount` out of the box.
- ✅ **No API key, no quota, no rate-limit headaches.**

### Fields returned per video

| Field | Description |
|-------|-------------|
| `videoId` | YouTube video ID |
| `url` | Canonical video URL |
| `title` | Video title |
| `channel` | Channel display name |
| `channelUrl` | Channel page URL |
| `duration` | Duration in seconds |
| `duration_string` | Human-readable duration (e.g. `12:34`) |
| `viewCount` | Lifetime view count |
| `uploadDate` | Upload date (`YYYY-MM-DD`) |
| `thumbnail` | Highest-resolution thumbnail URL |
| `language` | Language of the returned transcript |
| `sourceLanguage` | Original caption language before translation |
| `isAutoGenerated` | `true` if YouTube ASR auto-captions, `false` if human-made |
| `isTranslated` | `true` if the transcript was auto-translated |
| `availableLanguages` | All caption languages available (`manual` + `auto`) |
| `text` | **Full plain-text transcript** (clean, single string) |
| `transcript` | Array of `{ start, dur, end, text }` timestamped segments |
| `srt` | Transcript as an `.srt` subtitle string (optional) |
| `wordCount` / `characterCount` / `segmentCount` | Transcript statistics |
| `hasTranscript` | `true` when captions were found |

### Input

Pass one or more YouTube URLs in `videoUrls`. Everything else is optional.

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=IELMSD2kdmk",
    "https://youtu.be/dQw4w9WgXcQ",
    "https://www.youtube.com/shorts/abc123XYZ45"
  ],
  "preferredLanguages": ["en", "es"],
  "translateTo": "",
  "includeTimestamps": true,
  "includeSrt": false
}
```

| Input | Type | Description |
|-------|------|-------------|
| `videoUrls` | array | **Required.** Any number of YouTube video URLs or 11-char IDs. |
| `preferredLanguages` | array | Ordered ISO 639-1 codes. First available wins. Default `["en"]`. |
| `translateTo` | string | Optional. Auto-translate the transcript to this language. |
| `includeTimestamps` | boolean | Include the timestamped `transcript` array. Default `true`. |
| `includeSrt` | boolean | Also return an `.srt` subtitle string. Default `false`. |
| `proxyConfiguration` | object | Apify proxy settings. Default Apify Proxy works for most videos. |
| `cookies` | string | Optional Netscape `cookies.txt` for age/region-restricted videos. |

### Output

Each dataset record:

```json
{
  "videoId": "IELMSD2kdmk",
  "url": "https://www.youtube.com/watch?v=IELMSD2kdmk",
  "title": "Apache Spark in 5 Minutes",
  "channel": "Data Engineering",
  "duration": 312,
  "duration_string": "5:12",
  "viewCount": 184320,
  "uploadDate": "2023-04-18",
  "language": "en",
  "isAutoGenerated": true,
  "isTranslated": false,
  "availableLanguages": { "manual": ["en"], "auto": ["en", "es", "fr", "..."] },
  "text": "Apache Spark, an open-source data analytics engine that can process massive datasets...",
  "wordCount": 642,
  "characterCount": 3789,
  "segmentCount": 121,
  "transcript": [
    { "start": 0.32, "dur": 4.08, "end": 4.4, "text": "Apache Spark, an open-source data" },
    { "start": 2.48, "dur": 3.84, "end": 6.32, "text": "analytics engine that can process" }
  ],
  "hasTranscript": true
}
```

### Use cases

- **🤖 Feed videos to AI / LLMs** — turn any YouTube video into clean context for ChatGPT, Claude, summarizers, RAG pipelines and embeddings.
- **✍️ Content repurposing** — convert videos into blog posts, newsletters, show notes and social threads.
- **🎬 Subtitles & captions** — export SRT for video editors, accessibility and localization.
- **🔎 SEO research** — mine spoken keywords, topics and phrasing from top-ranking videos.
- **📚 Academic & market research** — analyze interviews, lectures, talks and earnings calls at scale.
- **📈 Competitor analysis** — extract what competitors actually *say* across their channel.
- **🌍 Translation & localization** — pull and auto-translate transcripts into 100+ languages.
- **📝 Note-taking & study** — searchable text from courses, tutorials and podcasts.

### How it works

Under the hood the actor uses [yt-dlp](https://github.com/yt-dlp/yt-dlp) — the gold-standard open-source extractor — to read YouTube's caption tracklist the same way a browser does, then fetches the timed-text document and parses it into clean segments. It tries multiple YouTube player clients and automatically retries failed videos on a direct connection (and a residential proxy when available), so you get reliable results without fiddling with settings. No reverse-engineered private APIs, no fragile DOM scraping.

### Languages

The actor returns transcripts in whatever languages a video has captions for — typically English plus YouTube's auto-generated set. With `translateTo`, you can auto-translate any transcript into **100+ languages**, including English, Spanish, Portuguese, French, German, Italian, Japanese, Korean, Chinese (Simplified & Traditional), Russian, Arabic, Hindi, Dutch, Polish, Turkish, Vietnamese, Indonesian, Thai and many more.

### Pricing

Pay only for what you use. The actor is small and fast (~1–3 seconds per video) and runs on minimal memory, so large batches stay cheap. See the **Pricing** tab for current rates and start with the free trial.

### FAQ

**How do I get the transcript of a YouTube video?**
Paste the video URL (or its 11-character ID) into `videoUrls` and run the actor. It returns the full plain-text transcript plus timestamped segments and, optionally, an SRT file — no manual copying from the YouTube transcript panel and no API key.

**Is there a free YouTube transcript generator?**
Yes — start with the free trial, then pay only for the compute you use. There's no YouTube Data API key, no OAuth and no daily quota, so bulk runs stay cheap.

**Do I need a YouTube Data API key?**
No. This actor works with no API key, no OAuth and no daily quota.

**Can I scrape many videos at once?**
Yes — that's the point. Put as many URLs as you want in `videoUrls` and they're all processed in one run.

**What if a video doesn't have my preferred language?**
List several languages in `preferredLanguages`; the first available one is used. If none exist, the actor falls back to the video's original captions and reports the language in the `language` field.

**Does it work with auto-generated captions?**
Yes. It uses human-made subtitles when available and falls back to YouTube's auto-generated captions. The `isAutoGenerated` flag tells you which.

**Can it translate transcripts?**
Yes. Set `translateTo` to any supported language code and the transcript is auto-translated via YouTube's caption translation.

**Does it support YouTube Shorts and live streams?**
Yes — Shorts (`/shorts/`), live (`/live/`), `youtu.be` short links and `/embed/` URLs are all supported, as are bare 11-character video IDs.

**What output formats can I export?**
JSON, CSV and Excel from the dataset, plus clean plain text and `.srt` subtitle strings inside each record.

**Why is a video returning no transcript?**
Some videos genuinely have captions disabled, or are private, age-gated or music videos with no caption track. The record will include `hasTranscript: false` and an explanatory `error`. For age/region-restricted videos, supply a `cookies.txt`.

**Is this legal?**
The actor extracts only publicly available captions. You are responsible for using the data in compliance with YouTube's Terms of Service and your local laws.

### Related actors

- **YouTube Video Info Scraper** — full video metadata, stats and tags without an API key.
- **YouTube Channel Scraper** — pull a channel's entire video history.
- **YouTube Downloader** — get downloadable MP4 / MP3 URLs.

***

Turn any YouTube video into clean, structured, AI-ready text — **in bulk, in any language.** 🚀

# Actor input Schema

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

One or more YouTube video URLs to pull transcripts/captions from. Add as many as you like — they are processed in a single run. Supports youtube.com/watch?v=, youtu.be/, /shorts/, /live/ and /embed/ links. Tip: paste a bare 11-character video ID and it still works.

## `preferredLanguages` (type: `array`):

Ordered list of ISO 639-1 language codes (e.g. en, es, fr). The actor returns the first one that exists for each video, preferring human-made subtitles over auto-generated ones. If none of your preferred languages exist, it falls back to the video's original-language captions and tells you which language it used. Leave as-is for English.

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

Optionally translate the transcript into another language using YouTube's built-in caption translation. Leave empty to return the original captions untouched.

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

Return the full timestamped segment array (start, dur, end, text) in addition to the plain-text transcript. Turn off if you only want the clean paragraph text.

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

Also return the transcript as a ready-to-use .srt subtitle string (great for captioning video editors). Off by default.

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

Captions are fetched through this proxy. Apify datacenter IPs are sometimes rate-limited by YouTube, so the actor automatically retries failed videos directly (and via the RESIDENTIAL group when available). The default works for most videos.

## `cookies` (type: `string`):

Optional. Paste the contents of a Netscape-format cookies.txt from a logged-in YouTube session to reach age-gated or region-restricted videos. See https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=IELMSD2kdmk"
  ],
  "preferredLanguages": [
    "en"
  ],
  "translateTo": "",
  "includeTimestamps": true,
  "includeSrt": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "cookies": ""
}
```

# 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=IELMSD2kdmk"
    ],
    "preferredLanguages": [
        "en"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("convertfleetdotonline/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": ["https://www.youtube.com/watch?v=IELMSD2kdmk"],
    "preferredLanguages": ["en"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("convertfleetdotonline/youtube-transcript-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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=IELMSD2kdmk"
  ],
  "preferredLanguages": [
    "en"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call convertfleetdotonline/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=convertfleetdotonline/youtube-transcript-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/f2AwB6DHeMkrFjCji/builds/DPAW8kZffgoqzyHob/openapi.json