# YouTube Transcript Turbo Saver ⚡💸 (`lofomachines/youtube-transcript-turbo-saver`) Actor

Fast, low-cost extraction of YouTube transcripts and metadata from videos or Shorts, with optional timestamps.

- **URL**: https://apify.com/lofomachines/youtube-transcript-turbo-saver.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** AI, Developer tools, Social media
- **Stats:** 13 total users, 1 monthly users, 100.0% runs succeeded, 1 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.

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 Turbo Saver — Extract YouTube Subtitles, Metadata & Full Transcripts at Scale

### What is YouTube Transcript Turbo Saver?

**YouTube Transcript Turbo Saver** is the fastest and most cost-effective Apify Actor for extracting transcripts, subtitles, and full video metadata from any YouTube video — including **regular videos, Shorts, and youtu.be links**.

***

### Why Choose This Over Other YouTube Transcript Actors?

| Feature | YouTube Transcript Turbo Saver | Competitors |
|---|---|---|
| Full video metadata | 35+ fields (stats, tags, description, thumbnails…) | Title + transcript only |
| YouTube Shorts support | Yes | Often missing |
| Cost per video | Ultra-low | Higher |
| Timestamps | Optional (on/off) | Sometimes hardcoded |
| Clean merged text output | Deduplicated, punctuation-aware merging | Raw segments only |

***

### Key Features

- **Extract YouTube transcripts** from any public video URL, Short, or youtu.be link
- **35+ metadata fields** per video: title, description, views, likes, comments, subscribers, tags, thumbnails, duration, language, and much more
- **Optional timestamps** — get structured `[{ timestamp, text }]` or clean merged plain text
- **Multi-language support** — automatically fetches available subtitle language
- **Batch processing** — process hundreds of videos in a single run
- **JSON output** ready for downstream integrations (n8n, Make, Zapier, custom APIs)

***

### Use Cases

- **AI Video Analysis** — Feed transcripts into GPT, Claude, or Gemini via n8n/Make to summarize, classify, or extract insights from YouTube content
- **Content Repurposing** — Convert YouTube videos into blog posts, newsletters, social media threads, or podcast show notes
- **SEO Research** — Analyze competitor video transcripts for keyword research and content gap analysis
- **Sentiment Analysis** — Run NLP on video transcripts to gauge audience sentiment and brand mentions
- **Market Research** — Monitor industry channels and extract key talking points at scale
- **Accessibility** — Generate subtitles/captions for videos that lack them
- **Academic Research** — Collect and analyze large video transcript datasets for studies
- **Lead Generation** — Extract contact info, product mentions, and CTAs from video content
- **Compliance Monitoring** — Track what influencers/partners say about your brand in videos
- **Training Data Collection** — Build datasets from YouTube transcripts for fine-tuning AI models

***

### Input Parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `videoUrls` | array | **Yes** | — | One or more YouTube video URLs (`youtube.com/watch`, `youtube.com/shorts`, `youtu.be`) |
| `includeTimestamps` | boolean | No | `true` | If `true`, returns transcript as array of `{ timestamp, text }` objects. If `false`, returns a single merged clean text string. |
| `proxyConfiguration` | object | No | Apify datacenter proxy | Proxy settings. Default uses Apify proxy. Set `{ "useApifyProxy": false }` to disable. |

#### Example Input

```json
{
    "videoUrls": [
        { "url": "https://www.youtube.com/watch?v=SieELGaJV8k" },
        { "url": "https://www.youtube.com/shorts/YWx4G5mHQ5k" },
        { "url": "https://youtu.be/dQw4w9WgXcQ" }
    ],
    "includeTimestamps": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

***

### Output — Complete Field Reference

Every video processed produces a **rich JSON object with 35+ fields**. This goes far beyond a simple transcript — you get the full video intelligence package.

#### Core Fields

| Field | Type | Description |
|---|---|---|
| `videoUrl` | string | The original YouTube URL provided as input |
| `videoId` | string | YouTube video ID (e.g., `dQw4w9WgXcQ`) |
| `videoTitle` | string | Full title of the video |
| `channelName` | string | Name of the YouTube channel |
| `channelId` | string | Unique YouTube channel ID |
| `description` | string | Full video description text |
| `publishedAt` | string | ISO 8601 publication date/time |

#### Engagement Metrics

| Field | Type | Description |
|---|---|---|
| `views` | string | Total view count |
| `subscribers` | string | Channel subscriber count |
| `likeCount` | string | Number of likes |
| `commentCount` | string | Number of comments |
| `favoriteCount` | string | Favorite count (legacy YouTube metric) |

#### Content Details

| Field | Type | Description |
|---|---|---|
| `duration` | string | Video duration (ISO 8601, e.g., `PT10M30S`) |
| `dimension` | string | Video dimension (`2d` or `3d`) |
| `definition` | string | Video quality definition (`hd` or `sd`) |
| `caption` | string | Whether captions are available (`true`/`false`) |
| `projection` | string | Video projection type (e.g., `rectangular`, `360`) |
| `tags` | array | Video tags/keywords set by the uploader |
| `categoryId` | string | YouTube category ID |
| `topicCategories` | array | Wikipedia URLs describing the video's topic categories |
| `defaultLanguage` | string | Original language of the video |
| `defaultAudioLanguage` | string | Language of the audio track |

#### Thumbnails

| Field | Type | Description |
|---|---|---|
| `thumbnails` | object | Nested object with thumbnail URLs at multiple resolutions (`default`, `medium`, `high`, `standard`, `maxres`), each with `url`, `width`, `height` |

#### Status & Rights

| Field | Type | Description |
|---|---|---|
| `uploadStatus` | string | Upload status (`processed`, `uploaded`, `rejected`, `deleted`, `failed`) |
| `privacyStatus` | string | Privacy setting (`public`, `unlisted`, `private`) |
| `license` | string | Video license (`youtube` or `creativeCommon`) |
| `embeddable` | boolean | Whether the video can be embedded on external sites |
| `publicStatsViewable` | boolean | Whether view stats are publicly visible |
| `madeForKids` | boolean | Whether the video is designated as child-directed |
| `licensedContent` | boolean | Whether the content is claimed by a YouTube content partner |
| `hasPaidProductPlacement` | boolean | Whether the video contains paid product placement |
| `contentRating` | object | Content rating information from various rating systems |

#### Localization

| Field | Type | Description |
|---|---|---|
| `localized` | object | Localized title and description for the video's default language |
| `localizations` | object | All available localizations (keyed by language code), each with `title` and `description` |

#### Live & Recording

| Field | Type | Description |
|---|---|---|
| `liveBroadcastContent` | string | Live status (`none`, `upcoming`, `live`) |
| `liveStreamingDetails` | object | For live/upcoming streams: `scheduledStartTime`, `actualStartTime`, `actualEndTime`, `concurrentViewers` |
| `recordingDetails` | object | Recording location and date when available |

#### Embed

| Field | Type | Description |
|---|---|---|
| `playerEmbedHtml` | string | HTML `<iframe>` embed code for the video player |

#### Transcript

| Field | Type | Description |
|---|---|---|
| `transcript` | array or string | **With timestamps:** array of `{ "text": "...", "timestamp": "0:05" }` objects. **Without timestamps:** single clean merged text string with deduplicated, punctuation-aware formatting. |

***

#### Example Output — With Timestamps (`includeTimestamps: true`)

```json
{
    "videoUrl": "https://www.youtube.com/watch?v=SieELGaJV8k",
    "videoId": "SieELGaJV8k",
    "videoTitle": "La guerra più breve della storia",
    "channelName": "Nova Lectio",
    "channelId": "UCKLp5MQ89ChJ4M14hIFoWtQ",
    "publishedAt": "2024-03-15T14:00:00Z",
    "description": "La guerra anglo-zanzibariana del 1896...",
    "thumbnails": {
        "default": { "url": "https://i.ytimg.com/vi/SieELGaJV8k/default.jpg", "width": 120, "height": 90 },
        "high": { "url": "https://i.ytimg.com/vi/SieELGaJV8k/hqdefault.jpg", "width": 480, "height": 360 },
        "maxres": { "url": "https://i.ytimg.com/vi/SieELGaJV8k/maxresdefault.jpg", "width": 1280, "height": 720 }
    },
    "tags": ["storia", "guerra", "zanzibar", "documentario"],
    "categoryId": "27",
    "defaultLanguage": "it",
    "defaultAudioLanguage": "it",
    "duration": "PT12M45S",
    "definition": "hd",
    "views": "1250000",
    "subscribers": "2400000",
    "likeCount": "85000",
    "commentCount": "3200",
    "privacyStatus": "public",
    "license": "youtube",
    "embeddable": true,
    "madeForKids": false,
    "hasPaidProductPlacement": false,
    "transcript": [
        { "text": "La guerra più breve del mondo è durata", "timestamp": "0:00" },
        { "text": "meno del nostro documentario sull'Oman.", "timestamp": "0:01" },
        { "text": "38 minuti. Per secoli Zanzibar fu la", "timestamp": "0:03" },
        { "text": "capitale dell'Oman. Questo arcipelago di", "timestamp": "0:05" }
    ]
}
```

#### Example Output — Without Timestamps (`includeTimestamps: false`)

```json
{
    "videoUrl": "https://www.youtube.com/watch?v=SieELGaJV8k",
    "videoId": "SieELGaJV8k",
    "videoTitle": "La guerra più breve della storia",
    "channelName": "Nova Lectio",
    "views": "1250000",
    "subscribers": "2400000",
    "transcript": "La guerra più breve del mondo è durata meno del nostro documentario sull'Oman. 38 minuti. Per secoli Zanzibar fu la capitale dell'Oman. Questo arcipelago di"
}
```

***

### How to Use

#### Step 1 — Run on Apify

1. [Sign up](https://apify.com/) or log in to Apify (free tier available).
2. Go to the [YouTube Transcript Turbo Saver](https://apify.com/store) Actor page.
3. Click **"Try for free"** and paste your YouTube URLs into the `videoUrls` field.
4. Toggle `includeTimestamps` on or off based on your needs.
5. Click **Start** and download your results as JSON, CSV, or Excel.

#### Step 2 — Use the API

Call the Actor programmatically via the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "videoUrls": [
      { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }
    ],
    "includeTimestamps": false
  }'
```

#### Step 3 — Integrate with n8n, Make, or Zapier

Use the Apify integration node in your automation platform to trigger the Actor and process results downstream.

***

### n8n Integration — Analyze YouTube Videos with AI

One of the most powerful ways to use this Actor is to combine it with **n8n** (open-source workflow automation) and an **AI model** (OpenAI GPT, Anthropic Claude, Google Gemini) to automatically analyze YouTube video content.

#### Workflow Architecture

```
YouTube URLs → Apify Actor → n8n → AI Analysis → Output (Google Sheets / Slack / Email / CRM)
```

#### Step-by-Step n8n Workflow

##### 1. Trigger Node (Cron / Webhook / Manual)

Set up a schedule (e.g., daily), a webhook endpoint, or a manual trigger to start the workflow.

##### 2. Apify Node — Run YouTube Transcript Turbo Saver

- Add the **Apify** node in n8n
- Select **"Run Actor"** operation
- Enter your Actor ID and Apify API token
- Pass input JSON:

```json
{
    "videoUrls": [
        { "url": "{{ $json.youtubeUrl }}" }
    ],
    "includeTimestamps": false
}
```

- Enable **"Wait for finish"** so n8n waits for the transcript extraction to complete

##### 3. HTTP Request Node — Fetch Dataset Results

- Use the Apify dataset API URL from the Actor output:
  ```
  https://api.apify.com/v2/datasets/{{datasetId}}/items?token=YOUR_TOKEN
  ```
- This returns the full array of video transcripts + metadata

##### 4. AI Node — Analyze Transcripts with GPT / Claude / Gemini

Add an **OpenAI**, **Anthropic**, or **HTTP Request** node (for Gemini) with a prompt like:

```
You are a YouTube video analyst. Analyze the following YouTube video transcript and metadata, then provide:

1. **Summary** (3-5 sentences)
2. **Key Topics** (bullet list of main subjects discussed)
3. **Sentiment** (positive / negative / neutral with confidence score)
4. **Target Audience** (who is this video for?)
5. **Content Quality Score** (1-10 with justification)
6. **SEO Keywords** (top 10 keywords for this content)
7. **Actionable Insights** (what can a marketer/creator learn from this?)
8. **Competitor Comparison Notes** (if applicable)

VIDEO METADATA:
- Title: {{ $json.videoTitle }}
- Channel: {{ $json.channelName }}
- Views: {{ $json.views }}
- Likes: {{ $json.likeCount }}
- Comments: {{ $json.commentCount }}
- Subscribers: {{ $json.subscribers }}
- Tags: {{ $json.tags }}
- Published: {{ $json.publishedAt }}
- Duration: {{ $json.duration }}
- Description: {{ $json.description }}

TRANSCRIPT:
{{ $json.transcript }}
```

##### 5. Output Node — Save or Notify

Route the AI analysis to one or more destinations:

- **Google Sheets** — Build a research database of analyzed videos
- **Slack / Discord** — Send AI summaries to your team channel
- **Airtable / Notion** — Organize insights in your knowledge base
- **Email** — Send daily digests of analyzed competitor content
- **Webhook** — Push results to your custom dashboard or CRM

#### Example n8n AI Analysis Outputs

With this workflow you can automatically generate:

| AI Analysis Output | Description |
|---|---|
| Video Summary | Concise 3-5 sentence summary of the video content |
| Key Topics Extraction | Structured list of main subjects discussed in the video |
| Sentiment Analysis | Positive/negative/neutral classification with confidence score |
| Keyword Extraction | Top SEO keywords found in the transcript |
| Content Classification | Auto-categorize videos by industry, topic, or content type |
| Brand Mention Detection | Detect when specific brands or products are mentioned |
| Competitor Intelligence | Compare messaging across competitor channels |
| Lead Scoring | Score videos for sales relevance based on content signals |
| Translation | Auto-translate transcripts to any language |
| Blog Post Draft | Generate a blog article from the video transcript |
| Social Media Posts | Create Twitter threads, LinkedIn posts from video highlights |
| FAQ Generation | Extract frequently asked questions from tutorial videos |
| Fact-Checking Flags | Identify claims that need verification |
| Ad / Sponsorship Detection | Detect sponsored segments in transcripts |

#### Advanced n8n Workflow Ideas

- **Bulk Channel Monitor** — Feed an entire channel's video list, extract all transcripts, and create a weekly AI-generated competitive brief
- **YouTube → Blog Pipeline** — Automatically convert new videos from your channel into SEO-optimized blog posts
- **Brand Mention Alerts** — Monitor industry YouTube channels for mentions of your brand, then alert your team via Slack
- **Training Data Pipeline** — Collect transcripts + metadata → clean with AI → export as JSONL for LLM fine-tuning
- **Multilingual Content Repurposing** — Extract transcript → translate to 5 languages → publish localized articles

***

### Troubleshooting

| Issue | Possible Cause | Solution |
|---|---|---|
| Empty transcript | Video has no subtitles/captions | Not all videos have transcripts. Try another video. |
| `Invalid URL` error | URL is malformed or not a YouTube link | Ensure the URL is a valid `youtube.com`, `youtu.be`, or `youtube.com/shorts` link. |
| Rate limit warnings in logs | Too many requests in a short time | The Actor handles this automatically with backoff + retry. For large batches, add a RESIDENTIAL proxy. |
| Timeout on large batches | Platform memory/time limits | Split into smaller batches (50-100 URLs per run). |

***

### FAQ

#### Does it work with YouTube Shorts?

Yes! Pass any `youtube.com/shorts/VIDEO_ID` URL and it will extract the transcript and metadata just like a regular video.

#### Can I process hundreds of videos in one run?

Yes. The Actor processes videos sequentially with smart delays to avoid rate limiting. For very large batches (500+), consider splitting into multiple runs.

#### What if a video has no transcript?

The Actor still returns the full metadata (title, views, tags, etc.). The `transcript` field will be an empty string or empty array.

#### Can I use my own proxy?

Yes. Configure the `proxyConfiguration` input with your own proxy URLs, or use the default Apify datacenter proxy.

***

### Integrations

YouTube Transcript Turbo Saver works with any platform that supports REST APIs or the Apify ecosystem:

- **n8n** — Open-source workflow automation (see detailed guide above)
- **Make (Integromat)** — Visual automation platform with native Apify integration
- **Zapier** — Connect to 5,000+ apps
- **LangChain / LlamaIndex** — Feed transcripts directly into RAG pipelines
- **Google Sheets** — Export results directly to spreadsheets
- **Python / Node.js / REST API** — Use the Apify API client in any language
- **Webhooks** — Get notified when a run completes

***

### Resources

- [Apify Platform](https://apify.com/)
- [Apify API Documentation](https://docs.apify.com/api/v2)
- [n8n Apify Integration](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/)
- [Discover other Scrapers](https://apify.com/lofomachines)

***

### Support

Found a bug or have a feature request? Visit my [Apify profile](https://apify.com/) or open an issue. I actively maintain this Actor and respond to feedback.

# Actor input Schema

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

Insert one or more YouTube URLs (watch, shorts, youtu.be).

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

If disabled, transcript will be merged into a single clean text without timestamps.

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

Select proxies to use. RESIDENTIAL proxies are strongly recommended for this Actor as the API may block datacenter IPs.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://www.youtube.com/watch?v=SieELGaJV8k"
    },
    {
      "url": "https://www.youtube.com/shorts/YWx4G5mHQ5k"
    }
  ],
  "includeTimestamps": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `run` (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=SieELGaJV8k"
        },
        {
            "url": "https://www.youtube.com/shorts/YWx4G5mHQ5k"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/youtube-transcript-turbo-saver").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=SieELGaJV8k" },
        { "url": "https://www.youtube.com/shorts/YWx4G5mHQ5k" },
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/youtube-transcript-turbo-saver").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": [
    {
      "url": "https://www.youtube.com/watch?v=SieELGaJV8k"
    },
    {
      "url": "https://www.youtube.com/shorts/YWx4G5mHQ5k"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call lofomachines/youtube-transcript-turbo-saver --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5udL0UDfFKcMrSKap/builds/qMlJC3jH9LO20T3K4/openapi.json