# YouTube Transcript Scraper — Full Text by Influship (`influship/youtube-transcript`) Actor

Extract the full transcript from any YouTube video in real time. Returns full text with timestamps and word count. Useful for content analysis, SEO, and AI workflows. No login required.

- **URL**: https://apify.com/influship/youtube-transcript.md
- **Developed by:** [Influship](https://apify.com/influship) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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

## YouTube Video Transcript Extractor

Extract full transcripts and captions from any YouTube video with timestamped segments, multiple language support, and word count metadata. Whether you need manual captions uploaded by the creator or auto-generated subtitles, this actor retrieves them in a clean, structured format ready for downstream processing.

### What is YouTube Transcript Extractor?

YouTube Transcript Extractor pulls the complete transcript from a YouTube video and returns it as structured data. It works with both manually uploaded captions and YouTube's automatic speech recognition (ASR) captions. You can request transcripts in any available language, and the response includes a list of all languages the video supports so you can make follow-up requests if needed.

The actor accepts either a full YouTube URL or a plain video ID, so you can paste links directly from your browser without needing to extract the ID yourself. It handles standard watch URLs, short youtu.be links, embed URLs, and Shorts URLs.

### What can this actor do?

- **Full transcript extraction** — Retrieve the complete spoken content of any YouTube video
- **Timestamped segments** — Each segment includes a start time and duration for precise alignment
- **Multiple language support** — Request transcripts in any language the video offers, including auto-generated translations
- **Auto-caption support** — Works with YouTube's automatic speech recognition when manual captions are not available
- **Available languages list** — Returns all languages the video has transcripts for, so you know what is available
- **Full text output** — Get the entire transcript as a single concatenated string for quick text analysis
- **Word count** — Includes a word count of the full transcript for content length estimation
- **Flexible input** — Accepts full YouTube URLs, short links, or bare video IDs

### What data can you extract?

| Field | Description |
|-------|-------------|
| video_id | The YouTube video ID |
| title | Title of the video |
| url | Full URL to the video |
| language | Language code of the returned transcript |
| source | Caption source — `manual` or `auto_generated` |
| available_languages | All caption tracks on the video — `[{ code, name, is_auto }, ...]` |
| full_text | The entire transcript as a single string |
| word_count | Total number of words in the transcript |
| transcript | Array of timestamped segments |
| transcript[].text | Text content of the segment |
| transcript[].start | Start time in seconds |
| transcript[].duration | Duration of the segment in seconds |
| scraped_at | When the transcript was scraped |

### Use cases

- **Content analysis** — Analyze what creators talk about in their videos without watching hours of footage
- **SEO research** — Extract keywords and topics from high-performing videos to inform your content strategy
- **Content repurposing** — Turn video transcripts into blog posts, social media threads, newsletters, or summaries
- **Accessibility auditing** — Verify that videos have accurate captions and check transcript quality
- **Competitive intelligence** — Monitor what competitors discuss in their video content at scale
- **Training data** — Collect spoken-word text for NLP model training or fine-tuning

### How to use

1. Enter a YouTube video ID or paste the full URL
2. Optionally set the language code (defaults to English)
3. Run the actor
4. Download the transcript as JSON, CSV, or Excel

### Input example

```json
{
  "videoId": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "language": "en"
}
````

### Output example

```json
{
  "video_id": "dQw4w9WgXcQ",
  "title": "Rick Astley - Never Gonna Give You Up",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "language": "en",
  "source": "manual",
  "available_languages": [
    { "code": "en", "name": "English", "is_auto": false },
    { "code": "es", "name": "Spanish", "is_auto": true },
    { "code": "fr", "name": "French", "is_auto": true }
  ],
  "full_text": "We're no strangers to love, you know the rules and so do I...",
  "word_count": 263,
  "transcript": [
    {
      "text": "We're no strangers to love",
      "start": 18.0,
      "duration": 3.5
    },
    {
      "text": "you know the rules and so do I",
      "start": 21.5,
      "duration": 3.2
    }
  ],
  "scraped_at": "2026-03-08T12:00:00Z"
}
```

### Pricing

This actor uses **pay-per-event** pricing:

- **Actor start**: Small fee per run
- **Per result**: Fee for each transcript returned

Platform usage costs are included — you only pay the per-event fees.

### FAQ

**What types of captions does this support?**
Both manually uploaded captions and YouTube's auto-generated captions (ASR). The actor retrieves whatever is available for the requested language.

**What if the video has no transcript?**
The actor will return an error indicating that no transcript is available for the video in the requested language. Check the available\_languages field to see what options exist.

**Can I get transcripts in multiple languages?**
Run the actor once per language. The first run will return the available\_languages list so you know which languages to request.

**Can I use this with the Apify API?**
Yes! Call this actor via the Apify API or any Apify integration (Zapier, Make, etc.)

# Actor input Schema

## `videoId` (type: `string`):

YouTube video ID or full URL. Supports formats like 'dQw4w9WgXcQ', 'https://www.youtube.com/watch?v=dQw4w9WgXcQ', or 'https://youtu.be/dQw4w9WgXcQ'

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

Language code for the transcript (e.g. 'en', 'es', 'fr'). Defaults to English if not specified.

## Actor input object example

```json
{
  "videoId": "dQw4w9WgXcQ",
  "language": "en"
}
```

# Actor output Schema

## `transcript` (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 = {
    "videoId": "dQw4w9WgXcQ"
};

// Run the Actor and wait for it to finish
const run = await client.actor("influship/youtube-transcript").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 = { "videoId": "dQw4w9WgXcQ" }

# Run the Actor and wait for it to finish
run = client.actor("influship/youtube-transcript").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 '{
  "videoId": "dQw4w9WgXcQ"
}' |
apify call influship/youtube-transcript --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Transcript Scraper — Full Text by Influship",
        "description": "Extract the full transcript from any YouTube video in real time. Returns full text with timestamps and word count. Useful for content analysis, SEO, and AI workflows. No login required.",
        "version": "0.0",
        "x-build-id": "A2cO2Ir2BgGHiwBEs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/influship~youtube-transcript/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-influship-youtube-transcript",
                "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/influship~youtube-transcript/runs": {
            "post": {
                "operationId": "runs-sync-influship-youtube-transcript",
                "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/influship~youtube-transcript/run-sync": {
            "post": {
                "operationId": "run-sync-influship-youtube-transcript",
                "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": [
                    "videoId"
                ],
                "properties": {
                    "videoId": {
                        "title": "Video ID or URL",
                        "type": "string",
                        "description": "YouTube video ID or full URL. Supports formats like 'dQw4w9WgXcQ', 'https://www.youtube.com/watch?v=dQw4w9WgXcQ', or 'https://youtu.be/dQw4w9WgXcQ'"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for the transcript (e.g. 'en', 'es', 'fr'). Defaults to English if not specified.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```