# Youtube Transcript Scraper (`scraply/youtube-transcript-scraper`) Actor

- **URL**: https://apify.com/scraply/youtube-transcript-scraper.md
- **Developed by:** [Scraply](https://apify.com/scraply) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does YouTube Transcript Scraper do?

The YouTube Transcript Scraper helps you pull transcripts directly from YouTube videos without the headache of manual typing. Instead of spending hours replaying and pausing clips, you paste a video link, and the scraper delivers the text in seconds.

It works across multiple languages, supports bulk video processing, and even includes smart proxy management to reduce errors and restrictions. Whether you need plain text, JSON, or timestamped captions, the scraper gives you structured outputs you can actually use.

Think of it as a time-saving assistant for creators, researchers, agencies, and educators. From building subtitles to analyzing video content, the YouTube Transcript Scraper turns unstructured video into usable text — quickly, accurately, and at scale.

### What YouTube Transcript Scraper can I extract?

With the YouTube Transcript Scraper, you’re not limited to just the spoken words. It can pull a wide range of video details, transcripts, and metadata to give you a complete snapshot of any YouTube video.

Here’s a breakdown of what you can extract:

| Data Type | Details Extracted |
| --- | --- |
| Transcript | Full video transcript in plain text, JSON, or XML. With or without timestamps. |
| Video Details | Title, description, post date, channel name, subscriber count, and video URL. |
| Engagement Metrics | Views, likes, dislikes, and sometimes comment counts for deeper audience insights. |
| Metadata | Tags, categories, chapters, hashtags, and video keywords. |
| Bulk Processing | Extract data from multiple videos or playlists at once, saving hours of manual work. |
| Multi-language Support | Pull transcripts in the original language or auto-translated versions. |

The beauty here is accuracy and scale. You can analyze a single video or scrape an entire channel’s library, all while keeping the data structured for quick use in your research, content strategy, or reporting.

#### Key Features of YouTube Transcript Scraper

The YouTube Transcript Scraper comes packed with features that make transcript extraction simple, reliable, and scalable. Instead of dealing with manual transcriptions or limited built-in options, this scraper gives you full control over how you collect and use video data.

Here are the standout features:

*   Transcript Extraction: Pull full transcripts from YouTube videos with or without timestamps.  
      
    
*   Bulk Processing: Handle multiple video URLs or entire playlists in one run.  
      
    
*   Multi-language Support: Extract transcripts in the original or auto-translated language.  
      
    
*   Flexible Output: Choose between plain text, JSON, XML, or structured arrays for easier integration.  
      
    
*   Metadata Collection: Capture titles, descriptions, views, post dates, and engagement metrics.  
      
    
*   Proxy Management: Smart proxies ensure smoother runs and reduce errors or restrictions.  
      
    
*   Custom Options: Decide how your transcripts appear — clean text only or with detailed time markers.  
      
    

This makes it a powerful tool for creators, researchers, and developers who need quick, accurate, and reusable video data.

### How to use YouTube Transcript Scraper

Using the YouTube Transcript Scraper is straightforward. You don’t need to be highly technical to get started — just follow a few simple steps and you’ll have clean transcripts in minutes.

Step-by-Step Guide

1.  Log in to Apify – Create a free account or sign in.  
      
    
2.  Select the Actor – Search for “YouTube Transcript Scraper” in the Apify store.  
      
    
3.  Enter Input Data – Paste your YouTube video URL(s) into the startUrls field.  
      
    
4.  Choose Options – Decide if you want timestamps or plain text.  
      
    
5.  Run the Actor – Hit start, and the scraper will extract the transcript automatically.  
      
    
6.  Download Results – Export your transcript in JSON, CSV, XML, or plain text format.  
      
#### Input
```json
{
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "urls": [
        "https://youtu.be/_AbFXuGDRTs"
    ]
}
````

#### Output

```json
[
  {
    "url": "https://youtu.be/_AbFXuGDRTs",
    "title": null,
    "channel_name": null,
    "length": null,
    "views": null,
    "message": "Error: 'NoneType' object has no attribute 'get'",
    "proxyTier": "DIRECT",
    "transcript": []
  }
]
```

### 🎯 Use Cases of YouTube Transcript Scraper

The YouTube Transcript Scraper isn’t just for pulling words out of videos — it opens doors for different kinds of work. From content creation to research, it gives you ready-to-use text that saves hours of manual effort.

Popular Use Cases

- Content Creators – Turn transcripts into blog posts, captions, newsletters, or repurpose for SEO-rich articles.

- Researchers & Students – Analyze interviews, lectures, or documentaries for topic modeling, sentiment analysis, or text mining.

- Accessibility – Provide subtitles and captions for audiences with hearing impairments.

- Marketers & Agencies – Extract quotes, snippets, or highlight reels for social media campaigns.

- Developers – Integrate transcripts into apps, chatbots, or search systems using structured JSON outputs.

- Educators – Create study guides, highlight key lessons, and make lecture content easier to review.

By scraping transcripts at scale, you turn video content into searchable, reusable, and shareable text assets.

### How many results can you scrape with YouTube Transcript Scraper?

The YouTube Transcript Scraper is built to handle both single videos and large-scale extractions. You can scrape an entire playlist or even a full channel’s video library, depending on how many URLs you feed into the input.

There’s no fixed hard limit on the number of results. Instead, it depends on:

- Number of video URLs provided – single, bulk list, or playlist.

- Your Apify plan – higher plans allow more credits for bigger scraping jobs.

- Video availability – only videos with transcripts enabled will return results.

In practical terms, you can scrape hundreds of videos at once by adding multiple URLs. For researchers or marketers working with entire channels, this makes the scraper especially valuable.

### How much will scraping YouTube Transcript Scraper cost you?

The YouTube Transcript Scraper is one of the most affordable tools for transcript extraction. You can get started for as little as $5 per month, which covers typical scraping needs for small to mid-scale projects.

Here’s how pricing usually works:

- Base Plan – $5/month for light users extracting a manageable number of transcripts.

- Scaling Up – If you need bulk processing (hundreds or thousands of videos), you may need higher Apify credits depending on usage.

- Pay-as-you-go Flexibility – Costs scale with the resources you consume, so you only pay for what you scrape.

This makes it a budget-friendly choice for creators, researchers, and developers who want reliable transcripts without expensive software or manual labor.

### Is it legal to scrape YouTube Transcript?

The short answer: it depends on how you use the data. The YouTube Transcript Scraper simply automates access to transcripts that are already available through YouTube. If a video has captions or transcripts enabled, the scraper retrieves that same information.

However, here are a few points to keep in mind:

- YouTube’s Terms of Service – Automated scraping may fall into gray areas. Always review the latest terms before large-scale usage.

- Fair Use – Using transcripts for research, accessibility, or educational purposes is usually safer.

- Commercial Use – Republishing transcripts without permission from the video owner could create legal issues.

- Private/Restricted Videos – Scraping content from private or region-restricted videos is not permitted.

In practice, scraping public transcripts for analysis, learning, or accessibility is widely accepted. But for redistribution or commercial reuse, always get the creator’s consent.

### FAQ: YouTube Transcript Scraper

#### 1. Can you get a transcript from a YouTube video?

Yes. If the video has captions or transcripts available, the YouTube Transcript Scraper can extract them quickly.

#### 2. Does YouTube provide transcripts by default?

Not for every video. Many videos have auto-generated captions, while some creators upload their own. If no transcript exists, the scraper will return null.

#### 3. Is there a free YouTube Transcript Scraper?

Yes. You can find YouTube Transcript Scraper free versions on GitHub or community tools, but they may have limitations. The Apify version is more reliable for bulk tasks.

#### 4. Can I use the scraper with Python?

Absolutely. Many developers use a YouTube Transcript Scraper Python script or the Apify API to automate transcript extraction in custom workflows.

#### 5. How many videos can I scrape at once?

You can scrape multiple URLs, full playlists, or even entire channels. The only limit depends on your Apify credits and whether transcripts exist.

#### 6. Is there a YouTube channel transcript scraper?

Yes. Some setups allow you to scrape every video in a channel by inputting the channel’s URL instead of a single video.

#### 7. Is scraping YouTube transcripts legal?

For research, accessibility, and personal use, it’s generally fine. But republishing transcripts without permission may violate YouTube’s Terms of Service.

#### 8. Where can I find the YouTube Transcript Scraper GitHub project?

Several open-source versions exist, like pintostudio YouTube Transcript Scraper GitHub, but they require manual setup. The Apify YouTube Transcript Scraper is easier to run without coding.

#### 9. Does it support multiple languages?

Yes. You can extract transcripts in the original video language or even auto-translated captions if YouTube provides them.

#### 10. What formats can I export the transcript in?

You can export as plain text, JSON, XML, or structured arrays with timestamps, making it flexible for analysis, development, or content reuse.

# Actor input Schema

## `urls` (type: `array`):

One or more YouTube video URLs to process. Each completed URL is appended immediately to the dataset.

## `includeEnglishAG` (type: `boolean`):

Whether to include English auto-generated transcripts

## `includeNonEnglish` (type: `boolean`):

Whether to include non-English transcripts

## `outputFormat` (type: `string`):

Format of transcript output: 'timestamp' returns detailed timestamps, 'text' returns plain text

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

Proxy configuration. Uses Apify RESIDENTIAL proxy by default to bypass YouTube IP blocking. If not configured, will try to use Apify proxy automatically.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=4KbrxIpQgkM"
  ],
  "includeEnglishAG": true,
  "includeNonEnglish": false,
  "outputFormat": "text",
  "proxyConfiguration": {}
}
```

# 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 = {
    "urls": [
        "https://www.youtube.com/watch?v=4KbrxIpQgkM"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraply/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 = { "urls": ["https://www.youtube.com/watch?v=4KbrxIpQgkM"] }

# Run the Actor and wait for it to finish
run = client.actor("scraply/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 '{
  "urls": [
    "https://www.youtube.com/watch?v=4KbrxIpQgkM"
  ]
}' |
apify call scraply/youtube-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Youtube Transcript Scraper",
        "version": "0.1",
        "x-build-id": "L8pK6hQRnB8I6o2sW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraply~youtube-transcript-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraply-youtube-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraply~youtube-transcript-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraply-youtube-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraply~youtube-transcript-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraply-youtube-transcript-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "YouTube URLs",
                        "type": "array",
                        "description": "One or more YouTube video URLs to process. Each completed URL is appended immediately to the dataset.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeEnglishAG": {
                        "title": "Include English Auto-Generated",
                        "type": "boolean",
                        "description": "Whether to include English auto-generated transcripts",
                        "default": true
                    },
                    "includeNonEnglish": {
                        "title": "Include Non-English Transcripts",
                        "type": "boolean",
                        "description": "Whether to include non-English transcripts",
                        "default": false
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "timestamp",
                            "text"
                        ],
                        "type": "string",
                        "description": "Format of transcript output: 'timestamp' returns detailed timestamps, 'text' returns plain text",
                        "default": "text"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy configuration. Uses Apify RESIDENTIAL proxy by default to bypass YouTube IP blocking. If not configured, will try to use Apify proxy automatically.",
                        "default": {}
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```