Pricing

from $1.49 / 1,000 transcripts

Try for free

Go to Apify Store

YouTube Transcript Scraper

Try for free

YouTube transcript scraper and API: get any video's transcript in about 3 seconds as text, timestamps, SRT or VTT subtitles, in its own language or translated. Built for AI agents, MCP and n8n. No captions, no charge. $2.99 per 1,000 on the Free plan, from $1.49 on paid plans.

Pricing

from $1.49 / 1,000 transcripts

Rating

0.0

(0)

Developer

nokia2k

Actor stats

Bookmarked

Total users

Monthly active users

a day ago

Last modified

What does YouTube Transcript Scraper do?

YouTube Transcript Scraper is a YouTube transcript API you run on Apify. It is an Actor (Apify's word for a ready-made tool that runs in the cloud) that reads the captions YouTube keeps for a video, the subtitles you can switch on in the player, written by a person or generated automatically. Paste video links, press Start, download the result. No YouTube API key, no Google login, no proxy to set up.

Why people pick it

About 3 seconds per call. One video took 2.5 to 4.1 seconds from start to finish, 30 videos 5.4 seconds, 160 videos 9 seconds.
Five formats in one run. Plain text, timestamped lines (segments), timestampedText, SRT and WebVTT, plus downloadable subtitle files if you want them. Extra formats cost nothing.
No language code to guess. Each video comes back in the language it is spoken in. Or pick from 70 languages, type any other code, or ask for YouTube's own machine translation.
A run never breaks your workflow. It always ends as Succeeded, with one row per link that says what happened in status and message. A video without captions is a free row, not a failed run.
You see what you paid for. Every row has a charged field: true only when a transcript was delivered.
Drop-in for single-video workflows. If your workflow sends videoUrl and targetLanguage and reads a data array, change only the Actor.

Measured speed and reliability

Total run time from start to finish on the Apify platform, 7–8 October 2026: one video 2.5–4.1 s, 30 videos 5.4 s, 160 videos 9 s. Speed depends on YouTube and on the videos, so your numbers will vary a little.

The first videos are requested while the Actor is still starting up.
A run with 1 to 3 videos, the typical automation call, asks YouTube over two lines at once from the first moment. The first answer wins.
A longer list is fetched 40 videos at a time, and a slow video gets a second line automatically.

Reliability, measured on 8 October 2026: 3,629 videos from 20 channels in two runs gave 3,447 transcripts, 171 videos without captions, 10 age-restricted videos, 1 video that failed on a timeout (0.03 %) and 0 blocked by YouTube. A set of 25 difficult videos (no captions, live, age-restricted, private, deleted, paid, blocked in the US, a 5-hour video, Japanese, Korean, Spanish, Shorts) all got the right answer.

Quick start: your first YouTube transcript in 5 steps

You need a web browser. Nothing to install.

Create a free Apify account. Open https://console.apify.com/sign-up. Click Continue with Google, or type an email and a password (8 characters or more), click Sign up and then the link in the email you receive. No email? Sign in again and click Resend verification email.
- You see: Apify Console, the web panel where Actors are run. The free plan gives $5 of credit every month, no credit card.
Open this Actor. Go to https://apify.com/nokia2k/youtube-transcript-scraper and click Try for free. Or, in Console, click Apify Store in the left menu and search for "YouTube Transcript Scraper".
- You see: the Input tab with a form. The first box, 📺 YouTube videos, holds two example links.
Paste your links, one per line, in place of the examples. Copy each link from your browser's address bar while the video is open. Leave the other settings alone.
Click Start.
- You see: the run begins. A few seconds later its status is Succeeded. A run is one execution of the Actor.
Open the Output tab, click Export, choose a format and click Download. Excel, CSV, JSON, XML, HTML table, RSS and JSONL are offered; Preview shows the result first.
- You see: first a table with one row per video (title, status, language, words, transcript). This table is the dataset, the place where a run stores its results. After Download, the file is in your Downloads folder.

The smallest input, in JSON (the Input tab has a switch between the form and JSON):

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"]
}

After your first run:

Subtitle files: tick 💾 Also save subtitle files I can download before Start.
For a spreadsheet: pick only Plain text in 📄 Output formats, or type segments into Omit fields in the export window. segments holds one entry per caption line and becomes hundreds of columns.
Old results: left menu Storage, Datasets tab, click the Dataset ID. On the free plan an unnamed dataset is deleted after 7 days. To keep it, open it and choose Rename in the Actions menu.

What data do you get from each video?

One row per link. On the run's Output tab, the Overview view shows the main columns, and the Subtitle files and Languages views show the rest. Transcript fields appear on rows with status: "success", for the formats you picked.

Every output field

Field	Meaning	Example
`status`	What happened. See Errors and troubleshooting	`success`
`message`	The reason in plain words when the status is not `success`, or a note such as a language fallback
`charged`	`true` when this row was charged	`true`
`input`	The value you pasted, to match rows to your list	`https://www.youtube.com/watch?v=arj7oStGLkU`
`scrapedAt`	When the row was made, UTC	`2026-10-08T09:00:00+00:00`
`videoId`, `url`	The 11-character ID and the standard link	`arj7oStGLkU`
`title`	Title of the video	Inside the Mind of a Master Procrastinator …
`channelName`, `channelId`	The channel and its ID	`TED`, `UCAuUUnT6oDeKwE6v1NGQxug`
`durationSeconds`, `viewCount`	Length in seconds; views at the time of the run	`844`, `62013820`
`description`, `keywords`, `thumbnailUrl`	The text under the video, the uploader's tags, the preview picture
`isLive`	`true` for live streams and their recordings	`false`
`language`, `languageName`	Code and name of the language you received	`en`, `English`
`isAutoGenerated`	`true` for YouTube's automatic captions, `false` when a person wrote them	`false`
`isTranslated`, `translatedFrom`	Whether the text is YouTube's machine translation, and from which language	`false`
`availableLanguages`	Every caption track of the video: `code`, `name`, `isAutoGenerated`, `isTranslatable`
`text`	The whole transcript as one clean paragraph	So in college, I was a government major, …
`timestampedText`	One line per caption: `[MM:SS] text`, or `[H:MM:SS] text` from one hour up	`[00:01] All right, so here we are, in front of the elephants`
`segments`	Caption lines with `start`, `duration` and `end` in seconds, and `text`	`{"start": 1.2, "duration": 2.16, "end": 3.36, "text": "…"}`
`srt`, `vtt`	The content of a `.srt` or `.vtt` (WebVTT) subtitle file
`files`	Download links of the saved files, by format. Only with `saveFiles`	`{"srt": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/jNQXAC9IVRw.srt"}`
`data`	Caption lines as `start`, `dur`, `text`. Only when the input used `videoUrl`
`segmentCount`, `wordCount`, `charCount`	Caption lines (or blocks), words and characters	`315`, `2277`, `12671`

Sample output: one success row and one no_captions row

Real values of 8 October 2026, with the text format. Long values are cut with "…", and availableLanguages shows only its first entry:

{
    "videoId": "arj7oStGLkU",
    "url": "https://www.youtube.com/watch?v=arj7oStGLkU",
    "status": "success",
    "message": "",
    "title": "Inside the Mind of a Master Procrastinator | Tim Urban | TED",
    "channelName": "TED",
    "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
    "durationSeconds": 844,
    "viewCount": 62013820,
    "description": "…",
    "keywords": ["…"],
    "thumbnailUrl": "https://i.ytimg.com/vi/arj7oStGLkU/…",
    "isLive": false,
    "language": "en",
    "languageName": "English",
    "isAutoGenerated": false,
    "isTranslated": false,
    "translatedFrom": null,
    "availableLanguages": [
        { "code": "en", "name": "English", "isAutoGenerated": false, "isTranslatable": true },
        "…"
    ],
    "segmentCount": 315,
    "wordCount": 2277,
    "charCount": 12671,
    "input": "https://www.youtube.com/watch?v=arj7oStGLkU",
    "scrapedAt": "2026-10-08T09:00:00+00:00",
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}

And a row from the same run for a video that has no captions. Its ID and title are placeholders; every other value is exactly what such a row carries:

{
    "videoId": "<11-character ID>",
    "url": "https://www.youtube.com/watch?v=<11-character ID>",
    "status": "no_captions",
    "message": "The video has no captions, neither uploaded nor auto-generated.",
    "title": "<title of the video>",
    "language": null,
    "availableLanguages": [],
    "segmentCount": 0,
    "wordCount": 0,
    "charCount": 0,
    "charged": false
}

Download YouTube subtitles as SRT and VTT files

With 💾 Also save subtitle files I can download on, each video gets one file per text format picked, named after the video: jNQXAC9IVRw.srt, jNQXAC9IVRw.vtt, jNQXAC9IVRw.txt, and jNQXAC9IVRw.timestamps.txt for the timestamped text. Open the links in the files field of the row, or find all files on the run's Storage tab under Key-value store (the place where a run keeps its files). The price stays the same.

Automatic captions stay on screen after the next line has started, so their raw times overlap. In srt and vtt each line is cut where the next begins, as subtitle players expect. segments keeps YouTube's original times.

Use cases

Give an AI agent the words of any video it is asked about, in about 3 seconds, so it answers from the source instead of guessing.
Summarize a video in n8n, Make or Zapier and send the key points to Slack, email or a Google Doc.
Download YouTube subtitles as SRT or VTT for video editing, captioning or a web player.
Turn a talk into a blog post, LinkedIn post or newsletter from the clean text field.
Translate a video's transcript into the language of your audience with YouTube's own machine translation.
Build a searchable archive or RAG knowledge base from timestamped blocks of about a minute each, so every answer can point to the moment in the video.

Ready-made examples: open one and press Start

Each link opens a saved setup that was tested before it was published, on a page of its own. Press Run example to get a working copy, then change the links or the formats.

Input examples

Every input field

Only the first field is required. The fields are listed in the order of the form, with the name used in JSON. The last five sit under ⚙️ More options.

Field in the form (JSON name)	What it is	Change it when	Example
📺 YouTube videos (`videoUrls`)	The videos you want: one link per line, or the 11-character video ID. One or thousands.	Always	`https://youtu.be/arj7oStGLkU`
🌐 Transcript language (`languages`)	The default, 🎬 Original language of the video (recommended) (`auto` in JSON), returns each video in the language it is spoken in. Or pick from 70 languages in order of preference: the first one the video has is used.	You need a specific language	`["es", "auto"]`: Spanish if it exists, otherwise the original
📄 Output formats (`outputFormats`)	The shapes of the transcript: `segments`, `text`, `timestampedText`, `srt`, `vtt`. Several cost the same as one. Default: `segments` and `text`.	You want subtitles, or only plain text	`["text"]`
📚 Also give me everything as one Markdown file (`combinedFile`)	Also writes all transcripts of the run into one file, `ALL_TRANSCRIPTS.md`, with a heading, the channel and the link for every video, in the run's Storage > Key-value store tab. Large runs are split into files of about 8 MB. Off by default; the price stays the same.	You want to upload everything to ChatGPT, Claude or NotebookLM in one go	`true`
💾 Also save subtitle files I can download (`saveFiles`)	One file per video for each text format picked, with download links in the row. Off by default.	You want files, not table cells	`true`
🔁 Translate to (`translateTo`)	YouTube's own machine translation, used when the video has no captions in that language. YouTube does not offer it for every video: then you get the original language and a note in `message`. Default: No translation.	Every transcript must be in one language	`"es"`
If my language is missing, give me the original language (`fallbackToAnyLanguage`)	On by default: a video without captions in your languages still returns its transcript in its own language.	Switch it off to skip those videos, free of charge	`false`
Caption type (`captionType`)	Any, human-made first (`any`), Human-made only (`manual`) or Auto-generated only (`auto`).	You want only captions written by people	`"manual"`
Merge caption lines into blocks (`mergeSegmentsSeconds`)	Joins YouTube's short caption lines into blocks of about this many seconds, 0 to 3600. 0 keeps the original lines. This is chunking for RAG and vector databases: each block is one RAG chunk with its start and end time.	Chapters, search indexes, RAG chunks for an AI knowledge base or a vector database	`60`
Include video details (`includeMetadata`)	Adds channel, duration, views, description, keywords and thumbnail. On by default. The title always comes.	Switch it off for smaller rows	`false`

More about languages:

No need to know the language in advance. The default takes the language YouTube's speech recognition heard, or the track YouTube marks as the default. If YouTube gives no hint at all, you get English when the video has it, and message says it was a guess.
Names work like codes: Spanish, español, Deutsch, Japanese. Codes outside the list work too, such as es-419.
Regional forms: en also finds en-GB and en-US. pt-BR matches itself and plain pt, not pt-PT.
Captions written by a person are preferred over automatic ones. isAutoGenerated tells you which you got, and availableLanguages lists every track the video has.

One video, for automations

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "outputFormats": ["text"]
}

A batch of videos

Paste as many links as you like. A video pasted twice is fetched and charged once.

{
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/jNQXAC9IVRw",
        "https://www.youtube.com/shorts/jNQXAC9IVRw"
    ],
    "outputFormats": ["text", "timestampedText"]
}

Spanish if it exists, otherwise the original language, with subtitle files

{
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/jNQXAC9IVRw"
    ],
    "languages": ["es", "auto"],
    "outputFormats": ["text", "srt"],
    "saveFiles": true
}

Translate every video into one language

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "translateTo": "es",
    "outputFormats": ["text", "vtt"]
}

isTranslated and translatedFrom tell you whether you got a translation. If YouTube offers none for a video, you get the original language and message says so.

One-minute blocks for an AI knowledge base

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "outputFormats": ["segments"],
    "mergeSegmentsSeconds": 60,
    "includeMetadata": false
}

Already have an n8n or Make workflow? Swap the Actor, keep the rest

Many n8n and Make workflows send one video per run in this shape:

{
    "videoUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "targetLanguage": "en"
}

and read the caption lines from a data array:

{
    "data": [
        { "start": "0.280", "dur": "4.440", "text": "All right, so here we are" }
    ]
}

This Actor works as a drop-in YouTube transcript node: it accepts exactly that input and returns the same data array, with start and dur as text, next to all its own fields (text, title, language, status and the rest). Change the Actor in your workflow and nothing else. data appears whenever the input uses the single videoUrl field. The names urls, startUrls, youtube_url and language are understood too.

Two things work better than you may be used to:

No captions in targetLanguage? You get the language the video is spoken in instead of an error. language says which and message explains.
No captions at all? The run still succeeds. The row has status: "no_captions", an empty data array and a message, and costs nothing.

Which YouTube links are accepted?

Watch links with or without extra parameters (https://www.youtube.com/watch?v=jNQXAC9IVRw&t=42s), short links (https://youtu.be/jNQXAC9IVRw), Shorts (https://www.youtube.com/shorts/jNQXAC9IVRw), live (https://www.youtube.com/live/jNQXAC9IVRw), embed, mobile and YouTube Music links, and the bare video ID (jNQXAC9IVRw). A link wrapped in quotes or brackets, or followed by a full stop, is cleaned up.

Channel and playlist links come back as unsupported_url, free of charge. For whole channels, playlists, search terms, date filters or "only new videos", see Related YouTube tools.

Run it every day or every week

Useful when the same list of videos must be fetched again and again, for example a fixed set of videos for a weekly report.

Fill the form as you want it.
Click Save as a new task at the top right of the Actor page. A task is a saved form with its own Start button. It appears under Saved tasks.
Run the task once by hand: an Actor must have run once before it can be scheduled.
In the left menu click Schedules, then Create new.
In the Schedule setup card choose how often (a cron expression or the visual builder) and your time zone. Next runs shows when it will run.
In the Add dropdown pick your task.
Click Enable. New schedules start disabled.

To receive the results after each run, add a webhook on the task's Integrations tab (event ACTOR.RUN.SUCCEEDED), or let n8n's Apify Trigger or Make's Watch Actor Runs pick them up (steps in Integrations).

This Actor fetches exactly the links you give it. To follow a channel and get only the videos that are new since the last run, use YouTube Scraper.

Use the YouTube Transcript API from AI agents (MCP)

MCP is the standard that lets an AI assistant use outside tools. Apify runs a hosted MCP server. This address gives the assistant this Actor as a tool:

https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper

Sign-in is OAuth: a browser window opens on the first connection and no token is stored in the configuration. A header Authorization: Bearer <YOUR_APIFY_TOKEN> works too. Each call is a normal run on your Apify account and costs the same as a run you start yourself. The assistant waits 30 seconds for a run by default (45 at most); one video takes about 3.

Claude.ai and Claude Desktop

Open Settings, then Connectors. In some versions the page is under Customize.
Click the add button and choose Add custom connector.
Fill in Name (for example YouTube transcripts) and Remote MCP server URL (the address above). Click Continue, then Add.
Sign in to Apify when the browser asks.
In a chat click +, then Connectors, and switch the connector on.
- You see: Claude asks permission the first time it uses the tool, runs it and answers from the transcript.

Free Claude accounts can add one custom connector. On Team and Enterprise plans, an Owner adds it once for the whole organization.

Claude Desktop with a local server

claude_desktop_config.json, needs Node.js:

{
  "mcpServers": {
    "youtube-transcripts": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "nokia2k/youtube-transcript-scraper"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}

Cursor

.cursor/mcp.json in your project, or ~/.cursor/mcp.json for all projects:

{
  "mcpServers": {
    "youtube-transcripts": {
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper"
    }
  }
}

With a token instead of OAuth, add "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" } next to "url".

VS Code

Needs GitHub Copilot. Open the Command Palette, run MCP: Open User Configuration and add the server:

{
  "servers": {
    "youtube-transcripts": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper"
    }
  }
}

Claude Code

claude mcp add --transport http youtube-transcripts \
  "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper" \
  --header "Authorization: Bearer $APIFY_TOKEN"

ChatGPT

Developer mode must be on. Settings > Apps & Connectors > Create; fill in Name, Description and MCP Server URL; set Authentication to OAuth; click Create. In a chat click +, then More, and pick the connector.

Example prompts

"Get the transcript of https://www.youtube.com/watch?v=arj7oStGLkU and list the five main ideas."
"Fetch the Spanish subtitles of this video as SRT and tell me how many lines they have: https://youtu.be/arj7oStGLkU"
"Read the transcripts of these three videos and write one comparison table of what each speaker recommends: [link 1] [link 2] [link 3]"

YouTube Transcript Scraper integrations: n8n, Make, Zapier, Python, JavaScript and LangChain

Your API token

Most tools ask for your API token: a secret key that lets another program use your Apify account. It is in Console under Settings, then API & Integrations. Here it is written <YOUR_APIFY_TOKEN>. Never share it and never put it in a shared file or a URL.

API: one call with curl

This call starts a run, waits for it and returns the rows, one per video:

curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-transcript-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"], "outputFormats": ["text"]}'

Note the ~ between the username and the Actor name. This address waits at most 300 seconds, then answers HTTP 408; one video takes about 3. For long lists start the run with POST /v2/acts/nokia2k~youtube-transcript-scraper/runs, wait until its status is SUCCEEDED, then read GET /v2/datasets/<DATASET_ID>/items?format=json&clean=true. Add maxTotalChargeUsd to cap the spend; format can also be csv or xlsx.

Python

pip install apify-client (version 3, Python 3.11 or newer):

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nokia2k/youtube-transcript-scraper").call(
    run_input={
        "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
        "outputFormats": ["text", "srt"],
    },
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["status"] == "success":
        print(item["title"], item["wordCount"], "words")
        print(item["text"][:200])
    else:
        print(item["input"], "->", item["status"], item["message"])

JavaScript

npm install apify-client:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('nokia2k/youtube-transcript-scraper').call({
    videoUrls: ['https://www.youtube.com/watch?v=arj7oStGLkU'],
    outputFormats: ['text'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.status, item.status === 'success' ? item.text.slice(0, 200) : item.message);
}

Read status on every row: the run succeeds even when a video has no transcript.

LangChain

pip install langchain-apify langchain-core, then set APIFY_API_TOKEN (the variable langchain-apify reads):

from langchain_apify import ApifyWrapper
from langchain_core.documents import Document

loader = ApifyWrapper().call_actor(
    actor_id="nokia2k/youtube-transcript-scraper",
    run_input={
        "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
        "outputFormats": ["text"],
    },
    dataset_mapping_function=lambda row: Document(
        page_content=row.get("text") or "",
        metadata={
            "source": row.get("url"),
            "title": row.get("title"),
            "status": row.get("status"),
        },
    ),
)
docs = [d for d in loader.load() if d.metadata["status"] == "success"]

To let an agent call the Actor by itself, use ApifyActorsTool("nokia2k/youtube-transcript-scraper").

n8n: one video in, transcript out

Install the Apify node. n8n Cloud: open the nodes panel, search Apify (under More from the community) and install it; an owner or admin has to do this. Self-hosted: Settings > Community Nodes, Install, type @apify/n8n-nodes-apify, accept the risks, Install. Needs n8n 1.57.0 or newer.
Add the Apify node after the node that gives you the link (a form, a webhook, a sheet row). Set Resource to Actor and Operation to Run an Actor and Get Dataset.
Connect your account: credential Apify API, token in API Key. On n8n Cloud, Apify OAuth2 API and Connect my account also work.
In Actor, select nokia2k/youtube-transcript-scraper.
In Input JSON, paste the one-video input from Input examples and put {{ $json.url }} in place of the link, keeping the quotation marks. That n8n expression takes the link from the previous node; use the field name your node has. Optional: Maximum Cost per Run (USD).
Execute the node.
- You see: one item per video with status, title and text. Use {{ $json.text }} in the next node.

Good to know:

Empty or odd output? You chose Run an Actor, which returns the description of the run. Use Run an Actor and Get Dataset.
A video without captions does not stop the workflow. Continue only when status equals success; log message otherwise.
HTTP Request node instead: Method POST, URL https://api.apify.com/v2/acts/nokia2k~youtube-transcript-scraper/run-sync-get-dataset-items, Authentication with the generic type Header auth (Name Authorization, Value Bearer <YOUR_APIFY_TOKEN>), Send Body on, Body Content Type JSON, Specify Body Using JSON.

Make: two modules

Add the Apify module Run an Actor. In Connection, sign in to Apify or paste your API token.
Choose this Actor in Actor, set Run synchronously to Yes (Make then waits for the result), paste the input into Input JSON and map your link into it.
Add the Apify module Get Dataset Items. In Dataset ID, map the defaultDatasetId from the first module. Not in the list yet? Run the scenario once and look again.
Add the module that receives the text and map text, title and status.
- You see: one result per video when you run the scenario.

With Run synchronously off, the next module reads an empty dataset. Synchronous runs in Make must be short: for anything longer than about 2 minutes, start with the trigger Watch Actor Runs, then Get Dataset Items. For many videos, raise Limit in Get Dataset Items.

Zapier: stay under 30 seconds

Zapier ends a synchronous Actor run after 30 seconds and the output is then lost. One video takes about 3 seconds, so one video per Zap run is safe.

Create a Zap with your trigger, for example a new row in a sheet.
Add the Apify action Run Actor. Connect with Allow Access, choose this Actor, paste the input, map the link, run it synchronously.
Add the Apify search Fetch Dataset Items to read the rows of that run.
Click Test step.
- You see: the fields of the row, text among them, ready for your next action.

Long lists need two Zaps. Zap A: your trigger, then Run Actor (asynchronous). Zap B: trigger Finished Actor Run, then Fetch Dataset Items, then your destination.

Google Sheets and Excel

Excel: Export, Excel, Download.
Google Sheets by hand: export as CSV or Excel and import the file in Sheets.
Google Sheets automatically: put the Google Sheets step of Make, Zapier or n8n after the Apify steps above.
Google Drive after every run: on the Actor's Integrations tab choose Upload results to GDrive, Connect with Google, set Filename and Format, Save. Files land in the folder Apify Uploads.

How much does it cost to get YouTube transcripts?

You pay per delivered transcript. No subscription.

Transcript: $2.99 per 1,000 on the Free plan at the time of writing, that is $0.00299 each. On paid Apify plans it is cheaper: $2.49 (Starter), $2.09 (Scale), $1.49 (Business). "Per 1,000" is only how the price is displayed: each transcript is charged singly, so 37 transcripts cost 37 × $0.00299 = $0.11.
Run start: Apify's own event, $0.00005 per run for each GB of memory. This Actor uses 1 GB by default, so $0.00005 per run.
Nothing else: no platform usage, no proxy fees. The price that counts is the one on the Pricing tab.

One run with	Transcripts delivered	Transcripts	Run start	Total
10 videos	10	$0.0299	$0.00005	$0.02995
1,000 videos	1,000	$2.99	$0.00005	$2.99005
10,000 videos	10,000	$29.90	$0.00005	$29.90005

Videos without a transcript are subtracted: 100 videos of which 12 have no captions cost 88 × $0.00299 = $0.26. An automation that sends 50 videos a day, one per call, for 30 days makes 1,500 runs: $4.485 for the transcripts plus $0.075 for the run starts, $4.56 in all.

Free plan: Apify gives $5 of credit every month, no card needed: about 1,600 transcripts a month at this price. Unused credit does not carry over.

Never charged: videos without captions; private, deleted, paid or age-restricted videos; entries that are not a video (channel and playlist links included); a video pasted twice (it is fetched once); blocked and error rows; videos a run did not reach; extra formats, subtitle files, translation and video details.

Cap a run: before Start, open Run options and fill in Maximum cost per run. The Actor stops at that amount and says how many videos were left. In the API the same limit is maxTotalChargeUsd, in n8n Maximum Cost per Run (USD).

Check a bill: charged says row by row what was billed. The page of a run shows its cost; Billing in Console shows the month.

Errors and troubleshooting

What each status means

Look at status. Every row that is not success is free.

`status`	What it means	What to do next
`success`	Transcript delivered. The only charged status	Use it. A `message` here is a note, for example about a language fallback
`no_captions`	The video has no captions at all, neither written by a person nor automatic. Or it is a live stream that is still running	Nothing can be fetched: the Actor does not listen to the audio. For a stream, run it again a few hours after it ends
`language_unavailable`	Captions exist, but not in the languages or caption type you allowed, and the fallback is off	Read `availableLanguages`, then change `languages` or `captionType`, or switch the fallback on
`video_unavailable`	Deleted or never existed	Check the link
`video_unplayable`	Private, paid, blocked in the region or removed by YouTube. `message` has YouTube's reason	It cannot be read
`age_restricted`	YouTube shows it only to signed-in adults	It cannot be read
`blocked`	YouTube refused every connection that was tried	Run it again later
`error`	Something unexpected. `message` says what	Run it again. If it repeats, open an issue with the run link
`invalid_input`	The entry is not a YouTube link or ID, or the input was empty	Copy the link again from the address bar
`unsupported_url`	A channel or playlist link	Paste the single video links, or use YouTube Scraper

Problems and solutions

"The run succeeded but a row has no text." Read its status and message in the table above. The usual reason is no_captions, common for music and videos without speech.
"I got another language than I asked for." The video has none of your languages and the fallback is on. language says what you got, availableLanguages what exists. Switch the fallback off to skip such videos instead.
"The text has no punctuation." It comes from automatic captions (isAutoGenerated: true). Choose Human-made only in Caption type if you need punctuation; videos without such captions then come back free as language_unavailable.
"n8n gives me empty or odd output." Use Run an Actor and Get Dataset, not Run an Actor.
"Make reads an empty dataset." Set Run synchronously to Yes, or use Watch Actor Runs for long runs.
"Zapier lost the result." A synchronous run there stops after 30 seconds. Use two Zaps.
"My export has hundreds of columns." Drop segments with Omit fields, or pick only Plain text.
"Rows are not in the order of my list." Rows arrive as the videos finish. Match them with input or videoId.
"Fewer rows than links." A video pasted twice gets one row. A spending cap or a timeout stops a run early; its final message says how many videos were not processed (those are free).
"A live stream has no transcript." It gets one once it has ended and YouTube has processed the recording: usually a few hours, up to a day for long streams, and some recordings never get captions.

Limits to know

It does not transcribe audio. It reads captions that exist on YouTube.
No age-restricted, private or members-only videos.
Video links only. Not channels, playlists or searches: see Related YouTube tools.
No publish date, likes, comments or dislikes in this Actor. YouTube shows dislikes to nobody.
Translation is YouTube's. translateTo depends on YouTube offering its machine translation for that video.
No word-level timing. Times are per caption line.
A row has a size limit. For an extremely long video the largest formats are left out of the row, starting with vtt and srt, and message says which. The plain text is kept.

FAQ

Why did a YouTube video come back without a transcript?

The row says why: status in one word, message in a sentence. The usual reason is no_captions, common for music and for videos without speech.

Am I charged when a video has no transcript?

No. Only success rows are charged, and charged is true only on those.

What does "per 1,000" mean, and what will my run cost?

On the Free plan, $2.99 buys 1,000 transcripts at the time of writing, so each costs $0.00299 (from $1.49 per 1,000 on paid plans). 200 transcripts cost about $0.60, plus $0.00005 per run start. See the cost table.

Can I get the transcript of YouTube Shorts?

Yes. Paste the youtube.com/shorts/... link. A Short has a transcript when it has captions.

Can I get the transcript of a YouTube live stream?

Yes, once the stream has ended and YouTube has processed the recording. Until then you get no_captions, free of charge. youtube.com/live/... links are accepted.

Can I get the transcripts of a whole channel or playlist?

Not with this Actor: such a link returns unsupported_url, free of charge. YouTube Scraper lists the videos of a channel or playlist itself.

Which language do I get, and can it translate YouTube subtitles?

The language the video is spoken in, unless you list other languages in order of preference. translateTo asks for YouTube's own machine translation. If you got a language you did not ask for, the video has none of yours and the fallback is on: message says so.

Does it transcribe the audio when a video has no captions?

No. It reads captions that already exist on YouTube.

Will YouTube block it? Do I need a proxy or a YouTube API key?

Nothing to set up: no proxy, no API key, no login. Two separate app identities and three kinds of connection are tried before a video is reported as blocked. In the test of 8 October 2026 YouTube blocked 0 of 3,629 videos. A blocked row is free: run it again later.

My run shows no data. Where are my results?

On the Output tab of the run; earlier runs are under Runs in the left menu. In n8n use Run an Actor and Get Dataset; in Make set Run synchronously to Yes. An empty input gives one invalid_input row.

Why is a field missing or empty?

Transcript fields come only for the formats you picked, on success rows. files needs saveFiles; data needs the videoUrl input. Video details are empty when Include video details is off.

Can I filter videos by date or get only new videos?

Not here: it fetches exactly the links you give it. YouTube Scraper limits a channel's videos by date and can deliver only the videos that are new since the last run.

Why do I have fewer rows than links?

A video pasted twice gets one row. Videos a run did not reach, because of a spending cap or a timeout, have no row and no charge; the final message of the run says how many.

Is there a YouTube transcript node for n8n?

Yes. Install Apify's verified n8n node, choose Run an Actor and Get Dataset and pick this Actor: each run returns the transcript in about 3 seconds. A workflow that already sends videoUrl and targetLanguage to another transcript Actor keeps working when you swap in this one, because the input and the data array are the same (see Input examples). Videos without captions cost nothing.

How do I send YouTube transcripts to n8n, Make, Zapier or Google Sheets?

Follow the steps in Integrations. n8n: Run an Actor and Get Dataset. Make: Run an Actor, then Get Dataset Items. Zapier: Run Actor, then Fetch Dataset Items. Sheets: Export as Excel or CSV.

Can ChatGPT or Claude use it?

Yes, through MCP. Add https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper as a connector and ask for a video's transcript in your own words. Steps in Use it from AI agents.

What do the timestamps mean? SRT or VTT?

A timestamp is the moment in the video at which a line is spoken: seconds from the beginning in segments, [MM:SS] in timestampedText. SRT suits video editors and most players, VTT suits video on web pages.

Can I get comments, likes or the publish date?

Not here. YouTube Scraper adds the exact publish date, likes, comments, chapters and more.

How many videos per run, and how many runs at once?

No fixed number of videos per run; 40 are fetched at a time. How many runs you can have at the same time depends on your Apify plan, for example 32 on Starter, 128 on Scale and 256 on Business.

What happens if a run is interrupted or reaches its time limit?

Rows are saved one by one, so nothing delivered is lost. Near a time limit the run stops taking new videos, ends normally and says how many are left. If Apify moves the run to another server, it continues where it stopped and never charges a video twice. The one case that ends as failed: after such a move the earlier results cannot be read back, so the run stops before fetching anything rather than risk charging a video twice.

Is it legal to download YouTube transcripts? What about private videos and dislikes?

The Actor reads only what YouTube shows publicly to any visitor. What you do with the texts is your responsibility: respect copyright and YouTube's terms. Private, members-only and age-restricted videos cannot be read, and dislikes are not available.

What do Actor, run, dataset and API token mean?

Actor: Apify's name for a ready-made tool that runs in the cloud.
Run: one execution of an Actor, from Start to the end.
Dataset: the table where a run stores its results. It is what the Output tab shows.
Key-value store: where a run keeps files, such as the subtitle files of saveFiles.
API and API token: a way for a program to start a run and read its results, and the secret key that proves the program acts for your account.
JSON: a text format for data: names and values between braces.
Captions and transcript: captions are the lines of text YouTube shows over a video; the transcript is all of them as one text.
Auto-generated captions: made by YouTube's speech recognition. They exist for many more videos but can contain mistakes and, in many languages, have no punctuation.
SRT and VTT: subtitle file types: lines of text with start and end times.
Pay per event: you are charged per delivered result, not per month.
MCP: the standard that lets AI assistants such as Claude and ChatGPT use outside tools.

Something went wrong. Where do I get help?

On the Issues tab of this Actor. See Support and updates.

This developer publishes three YouTube Actors. Pick by what you start from and what you need back. Prices per 1,000 results on the Free plan at the time of writing; paid Apify plans pay less.

Actor	Use it when you have	You get	Price
YouTube Video to Text 📝	A big list of video links, a playlist or a channel	Plain text only, the lowest price	$1.99
YouTube Transcript Scraper ⚡ (you are here)	Video links, and someone is waiting	Text, timestamps, SRT, VTT, translation, in about 3 s	$2.99
YouTube Scraper 🧰	Links, a channel, a playlist or a topic, and you need numbers	Transcript plus likes, comments, chapters, channel facts	$4.99

Support and updates

Something does not behave as described, or a field is missing? Open an issue on the Issues tab of this Actor. Include the link to the run (copy it from the address bar while the run is open), the link to the video, and what you expected.

Last updated: October 2026.

Get your first transcript: paste one link and click Start.

🇪🇸 Guía completa en español

Consigue la transcripción de YouTube de cualquier video en unos 3 segundos: texto limpio, líneas con marcas de tiempo y subtítulos SRT y VTT, en el idioma del propio video o traducidos, para agentes de IA, n8n, Make y tu propio código.

$2.99 por cada 1000 transcripciones con el plan Free de Apify, y desde $1.49 con los planes de pago (precios en el momento de escribir esto): tres décimas de centavo o menos cada una.

Los videos que fallan o no tienen subtítulos nunca se cobran.

Este Actor (así llama Apify a una herramienta lista para usar que funciona en la nube) lee los subtítulos que YouTube guarda de cada video, los que puedes activar en el reproductor, escritos por una persona o generados automáticamente. Pegas enlaces de videos, haces clic en Start («Iniciar») y descargas el resultado. No necesitas clave de API de YouTube, ni cuenta de Google, ni configurar proxies.

Las pantallas de Apify están en inglés. Por eso los botones y pestañas aparecen aquí en inglés y en negrita, con su significado entre comillas angulares la primera vez. Los nombres de los campos, los valores de status y el JSON también se quedan en inglés.

Por qué lo eligen

Unos 3 segundos por llamada. Un video tardó de 2.5 a 4.1 segundos de principio a fin; 30 videos, 5.4 segundos; 160 videos, 9 segundos.
Cinco formatos en una sola ejecución. Texto plano, líneas con marcas de tiempo (segments), timestampedText, SRT y WebVTT, y archivos de subtítulos descargables si los quieres. Los formatos adicionales no cuestan nada.
No hay que adivinar códigos de idioma. Cada video llega en el idioma en que se habla. O elige entre 70 idiomas, escribe cualquier otro código o pide la traducción automática de YouTube.
Una ejecución nunca rompe tu flujo. Siempre termina como Succeeded («completada»), con una fila por enlace que dice qué pasó en status y message. Un video sin subtítulos es una fila gratuita, no una ejecución fallida.
Ves lo que pagaste. Cada fila tiene un campo charged: vale true solo cuando se entregó una transcripción.
Sustituto directo para flujos de un solo video. Si tu flujo envía videoUrl y targetLanguage y lee una lista data, cambia solo el Actor.

Velocidad y fiabilidad medidas

Tiempo total de la ejecución, de principio a fin, en la plataforma de Apify, 7 y 8 de octubre de 2026: un video, de 2.5 a 4.1 s; 30 videos, 5.4 s; 160 videos, 9 s. La velocidad depende de YouTube y de los videos, así que tus cifras variarán un poco.

Los primeros videos se piden mientras el Actor todavía está arrancando.
Una ejecución con 1 a 3 videos, la llamada típica de una automatización, pregunta a YouTube por dos líneas a la vez desde el primer momento. Gana la primera respuesta.
Una lista más larga se procesa de 40 en 40 videos, y un video lento recibe una segunda línea automáticamente.

Fiabilidad, medida el 8 de octubre de 2026: 3629 videos de 20 canales en dos ejecuciones dieron 3447 transcripciones, 171 videos sin subtítulos, 10 videos con restricción de edad, 1 video fallido por tiempo agotado (0.03 %) y 0 bloqueados por YouTube. Un conjunto de 25 videos difíciles (sin subtítulos, en directo, con restricción de edad, privados, borrados, de pago, bloqueados en Estados Unidos, un video de 5 horas, en japonés, coreano y español, Shorts) recibió en todos los casos la respuesta correcta.

Inicio rápido: tu primera transcripción de YouTube en 5 pasos

Solo necesitas un navegador web. No hay nada que instalar.

Crea una cuenta gratuita de Apify. Entra en https://console.apify.com/sign-up. Haz clic en Continue with Google («Continuar con Google»), o escribe un correo y una contraseña (8 caracteres o más), haz clic en Sign up («Registrarse») y después en el enlace del correo que recibirás. ¿No llega el correo? Inicia sesión otra vez y haz clic en Resend verification email («Reenviar el correo de verificación»).
- Verás: Apify Console («Consola de Apify»), el panel web donde se ejecutan los Actors. El plan gratuito da $5 de crédito cada mes, sin tarjeta.
Abre este Actor. Entra en https://apify.com/nokia2k/youtube-transcript-scraper y haz clic en Try for free («Probar gratis»). O bien, en la consola, haz clic en Apify Store («tienda de Apify») en el menú de la izquierda y busca "YouTube Transcript Scraper".
- Verás: la pestaña Input («Entrada») con un formulario. La primera casilla, 📺 YouTube videos («Videos de YouTube»), trae dos enlaces de ejemplo.
Pega tus enlaces, uno por línea, en lugar de los ejemplos. Copia cada enlace de la barra de direcciones del navegador con el video abierto. No toques los demás ajustes.
Haz clic en Start («Iniciar»).
- Verás: la ejecución empieza y, unos segundos después, su estado es Succeeded («completada»). Una ejecución es cada vez que el Actor trabaja.
Abre la pestaña Output («Salida»), haz clic en Export («Exportar»), elige un formato y haz clic en Download («Descargar»). Puedes elegir Excel, CSV, JSON, XML, HTML table, RSS y JSONL; Preview («Vista previa») te enseña el resultado antes.
- Verás: primero una tabla con una fila por video (título, estado, idioma, palabras, transcripción). Esa tabla es el dataset («conjunto de resultados»), el lugar donde una ejecución guarda lo que obtuvo. Después de Download, el archivo está en tu carpeta Descargas.

La entrada más pequeña, en JSON (la pestaña Input tiene un selector entre el formulario y JSON):

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"]
}

Después de tu primera ejecución:

Archivos de subtítulos: marca 💾 Also save subtitle files I can download («Guardar también archivos de subtítulos que pueda descargar») antes de hacer clic en Start.
Para una hoja de cálculo: elige solo Plain text («Texto plano») en 📄 Output formats («Formatos de salida»), o escribe segments en Omit fields («Excluir campos») en la ventana de exportación. segments tiene una entrada por línea de subtítulo y se convierte en cientos de columnas.
Resultados antiguos: menú de la izquierda Storage («Almacenamiento»), pestaña Datasets, y haz clic en el Dataset ID («identificador del conjunto de resultados»). En el plan gratuito, un dataset sin nombre se borra a los 7 días. Para conservarlo, ábrelo y elige Rename («Cambiar nombre») en el menú Actions («Acciones»).

Qué datos recibes de cada video

Una fila por enlace. Los campos de la transcripción aparecen en las filas con status: "success", para los formatos que elegiste.

Todos los campos de salida

Campo	Qué significa	Ejemplo
`status`	Qué pasó. Mira «Errores y solución de problemas»	`success`
`message`	El motivo en palabras sencillas cuando el estado no es `success`, o una nota, por ejemplo sobre un cambio de idioma
`charged`	`true` cuando esta fila se cobró	`true`
`input`	El valor que pegaste, para emparejar filas con tu lista	`https://www.youtube.com/watch?v=arj7oStGLkU`
`scrapedAt`	Cuándo se creó la fila, en UTC	`2026-10-08T09:00:00+00:00`
`videoId`, `url`	El identificador de 11 caracteres y el enlace estándar	`arj7oStGLkU`
`title`	Título del video	Inside the Mind of a Master Procrastinator …
`channelName`, `channelId`	El canal y su identificador	`TED`, `UCAuUUnT6oDeKwE6v1NGQxug`
`durationSeconds`, `viewCount`	Duración en segundos; visualizaciones en el momento de la ejecución	`844`, `62013820`
`description`, `keywords`, `thumbnailUrl`	El texto bajo el video, las etiquetas de quien lo subió y la imagen de vista previa
`isLive`	`true` para directos y sus grabaciones	`false`
`language`, `languageName`	Código y nombre del idioma que recibiste	`en`, `English`
`isAutoGenerated`	`true` para los subtítulos automáticos de YouTube, `false` cuando los escribió una persona	`false`
`isTranslated`, `translatedFrom`	Si el texto es la traducción automática de YouTube, y desde qué idioma	`false`
`availableLanguages`	Todas las pistas de subtítulos del video: `code`, `name`, `isAutoGenerated`, `isTranslatable`
`text`	Toda la transcripción como un solo párrafo limpio	So in college, I was a government major, …
`timestampedText`	Una línea por subtítulo: `[MM:SS] texto`, o `[H:MM:SS] texto` a partir de una hora	`[00:01] All right, so here we are, in front of the elephants`
`segments`	Líneas de subtítulos con `start`, `duration` y `end` en segundos, y `text`	`{"start": 1.2, "duration": 2.16, "end": 3.36, "text": "…"}`
`srt`, `vtt`	El contenido de un archivo de subtítulos `.srt` o `.vtt` (WebVTT)
`files`	Enlaces de descarga de los archivos guardados, por formato. Solo con `saveFiles`	`{"srt": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/jNQXAC9IVRw.srt"}`
`data`	Líneas de subtítulos como `start`, `dur`, `text`. Solo cuando la entrada usó `videoUrl`
`segmentCount`, `wordCount`, `charCount`	Líneas de subtítulos (o bloques), palabras y caracteres	`315`, `2277`, `12671`

Ejemplo de salida: una fila correcta y una fila no_captions

Valores reales del 8 de octubre de 2026, con el formato text. Los valores largos se cortan con "…", y availableLanguages muestra solo su primera entrada:

{
    "videoId": "arj7oStGLkU",
    "url": "https://www.youtube.com/watch?v=arj7oStGLkU",
    "status": "success",
    "message": "",
    "title": "Inside the Mind of a Master Procrastinator | Tim Urban | TED",
    "channelName": "TED",
    "channelId": "UCAuUUnT6oDeKwE6v1NGQxug",
    "durationSeconds": 844,
    "viewCount": 62013820,
    "description": "…",
    "keywords": ["…"],
    "thumbnailUrl": "https://i.ytimg.com/vi/arj7oStGLkU/…",
    "isLive": false,
    "language": "en",
    "languageName": "English",
    "isAutoGenerated": false,
    "isTranslated": false,
    "translatedFrom": null,
    "availableLanguages": [
        { "code": "en", "name": "English", "isAutoGenerated": false, "isTranslatable": true },
        "…"
    ],
    "segmentCount": 315,
    "wordCount": 2277,
    "charCount": 12671,
    "input": "https://www.youtube.com/watch?v=arj7oStGLkU",
    "scrapedAt": "2026-10-08T09:00:00+00:00",
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}

Un video sin subtítulos en la misma ejecución. El identificador y el título son marcadores; los demás valores son los que lleva una fila así:

{
    "videoId": "<11-character ID>",
    "url": "https://www.youtube.com/watch?v=<11-character ID>",
    "status": "no_captions",
    "message": "The video has no captions, neither uploaded nor auto-generated.",
    "title": "<title of the video>",
    "language": null,
    "availableLanguages": [],
    "segmentCount": 0,
    "wordCount": 0,
    "charCount": 0,
    "charged": false
}

Descargar subtítulos de YouTube como archivos SRT y VTT

Con 💾 Also save subtitle files I can download activado, cada video recibe un archivo por cada formato de texto elegido, con el nombre del video: jNQXAC9IVRw.srt, jNQXAC9IVRw.vtt, jNQXAC9IVRw.txt, y jNQXAC9IVRw.timestamps.txt para el texto con marcas de tiempo. Abre los enlaces del campo files de la fila, o encuentra todos los archivos en la pestaña Storage de la ejecución, en Key-value store («almacén de archivos»), el lugar donde una ejecución guarda sus archivos. El precio no cambia.

Los subtítulos automáticos siguen en pantalla cuando ya ha empezado la línea siguiente, así que sus tiempos originales se solapan. En srt y vtt cada línea se corta donde empieza la siguiente, como esperan los reproductores. segments conserva los tiempos originales de YouTube.

Casos de uso

Dale a un agente de IA las palabras de cualquier video sobre el que le pregunten, en unos 3 segundos, para que responda desde la fuente en lugar de adivinar.
Resume un video en n8n, Make o Zapier y envía las ideas clave a Slack, al correo o a un documento de Google.
Descarga subtítulos de YouTube en SRT o VTT para editar video, subtitular o usar en un reproductor web.
Convierte una charla en un artículo, una publicación de LinkedIn o un boletín a partir del campo limpio text.
Traduce la transcripción de un video al idioma de tu público con la traducción automática de YouTube.
Crea un archivo consultable o una base de conocimiento RAG con bloques de un minuto con marca de tiempo, para que cada respuesta pueda señalar el momento exacto del video.

Ejemplos listos para usar: ábrelo y pulsa Start

Cada ejemplo es una configuración guardada y probada, con su propia página. Ábrelo, pulsa Run example y tendrás una copia que funciona y que puedes cambiar.

Ejemplos de entrada

Todos los campos de entrada

Solo el primer campo es obligatorio. Los campos van en el orden del formulario, con el nombre que se usa en JSON. Los cinco últimos están en ⚙️ More options («Más opciones»).

Campo del formulario (nombre en JSON)	Qué es	Cámbialo cuando	Ejemplo
📺 YouTube videos (`videoUrls`)	Los videos que quieres: un enlace por línea, o el identificador de 11 caracteres. Uno o miles.	Siempre	`https://youtu.be/arj7oStGLkU`
🌐 Transcript language (`languages`)	El valor por defecto, 🎬 Original language of the video (recommended) («Idioma original del video, recomendado»; `auto` en JSON), devuelve cada video en el idioma en que se habla. O elige entre 70 idiomas por orden de preferencia: se usa el primero que tenga el video.	Necesitas un idioma concreto	`["es", "auto"]`: español si existe; si no, el original
📄 Output formats (`outputFormats`)	Las formas de la transcripción: `segments`, `text`, `timestampedText`, `srt`, `vtt`. Varias cuestan lo mismo que una. Por defecto: `segments` y `text`.	Quieres subtítulos, o solo texto plano	`["text"]`
📚 Also give me everything as one Markdown file (`combinedFile`)	«Dame también todo en un archivo Markdown». Escribe además todas las transcripciones de la ejecución en un solo archivo, `ALL_TRANSCRIPTS.md`, con un título, el canal y el enlace de cada video, en la pestaña Storage > Key-value store de la ejecución. Las ejecuciones grandes se dividen en archivos de unos 8 MB. Desactivado por defecto; el precio no cambia.	Quieres subirlo todo de una vez a ChatGPT, Claude o NotebookLM	`true`
💾 Also save subtitle files I can download (`saveFiles`)	Un archivo por video para cada formato de texto elegido, con enlaces de descarga en la fila. Desactivado por defecto.	Quieres archivos, no celdas de una tabla	`true`
🔁 Translate to (`translateTo`)	La traducción automática de YouTube, que se usa cuando el video no tiene subtítulos en ese idioma. YouTube no la ofrece para todos los videos: entonces recibes el idioma original y una nota en `message`. Por defecto: No translation («Sin traducción»).	Todas las transcripciones deben estar en un idioma	`"es"`
If my language is missing, give me the original language (`fallbackToAnyLanguage`)	«Si falta mi idioma, dame el original». Activado por defecto: un video sin subtítulos en tus idiomas devuelve igualmente su transcripción en su propio idioma.	Desactívalo para omitir esos videos, sin coste	`false`
Caption type (`captionType`)	«Tipo de subtítulos»: Any, human-made first («Cualquiera, primero los de personas»; `any`), Human-made only («Solo de personas»; `manual`) o Auto-generated only («Solo automáticos»; `auto`).	Quieres solo subtítulos escritos por personas	`"manual"`
Merge caption lines into blocks (`mergeSegmentsSeconds`)	«Unir líneas en bloques»: junta las líneas cortas de YouTube en bloques de unos tantos segundos, de 0 a 3600. 0 conserva las líneas originales. Es la división en fragmentos (chunking) para RAG y bases de datos vectoriales: cada bloque es un fragmento (chunk) de RAG con su hora de inicio y de fin.	Capítulos, índices de búsqueda, chunks de RAG para una base de conocimiento de IA o una base de datos vectorial	`60`
Include video details (`includeMetadata`)	«Incluir datos del video»: añade canal, duración, visualizaciones, descripción, etiquetas y miniatura. Activado por defecto. El título llega siempre.	Desactívalo para filas más pequeñas	`false`

Más sobre los idiomas:

No necesitas saber el idioma de antemano. El valor por defecto toma el idioma que oyó el reconocimiento de voz de YouTube, o la pista que YouTube marca como predeterminada. Si YouTube no da ninguna pista, recibes inglés cuando el video lo tiene, y message dice que fue una suposición.
Los nombres funcionan como los códigos: Spanish, español, Deutsch, Japanese. También sirven códigos que no están en la lista, como es-419.
Variantes regionales: en también encuentra en-GB y en-US. pt-BR encuentra pt-BR y pt a secas, no pt-PT.
Se prefieren los subtítulos escritos por una persona a los automáticos. isAutoGenerated te dice cuáles recibiste, y availableLanguages enumera todas las pistas del video.

Un video, para automatizaciones

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "outputFormats": ["text"]
}

Un lote de videos

Pega tantos enlaces como quieras. Un video pegado dos veces se pide y se cobra una sola vez.

{
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/jNQXAC9IVRw",
        "https://www.youtube.com/shorts/jNQXAC9IVRw"
    ],
    "outputFormats": ["text", "timestampedText"]
}

Español si existe; si no, el idioma original, con archivos de subtítulos

{
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/jNQXAC9IVRw"
    ],
    "languages": ["es", "auto"],
    "outputFormats": ["text", "srt"],
    "saveFiles": true
}

Traducir todos los videos a un idioma

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "translateTo": "es",
    "outputFormats": ["text", "vtt"]
}

isTranslated y translatedFrom te dicen si recibiste una traducción. Si YouTube no ofrece ninguna para un video, recibes el idioma original y message lo indica.

Bloques de un minuto para una base de conocimiento de IA

{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "outputFormats": ["segments"],
    "mergeSegmentsSeconds": 60,
    "includeMetadata": false
}

¿Ya tienes un flujo en n8n o Make? Cambia el Actor y deja todo lo demás

Muchos flujos de n8n y Make envían un video por ejecución con esta forma:

{
    "videoUrl": "https://www.youtube.com/watch?v=jNQXAC9IVRw",
    "targetLanguage": "en"
}

y leen las líneas de subtítulos de una lista data:

{
    "data": [
        { "start": "0.280", "dur": "4.440", "text": "All right, so here we are" }
    ]
}

Este Actor acepta exactamente esa entrada y devuelve la misma lista data, con start y dur como texto, junto a todos sus propios campos (text, title, language, status y los demás). Cambia el Actor en tu flujo y nada más. data aparece siempre que la entrada use el campo único videoUrl. También se entienden los nombres urls, startUrls, youtube_url y language.

Dos cosas funcionan mejor de lo que quizá estás acostumbrado:

¿No hay subtítulos en targetLanguage? Recibes el idioma en que se habla el video en lugar de un error. language dice cuál y message lo explica.
¿No hay subtítulos de ningún tipo? La ejecución termina bien igualmente. La fila tiene status: "no_captions", una lista data vacía y un message, y no cuesta nada.

Qué enlaces de YouTube se aceptan

Enlaces de reproducción con o sin parámetros adicionales (https://www.youtube.com/watch?v=jNQXAC9IVRw&t=42s), enlaces cortos (https://youtu.be/jNQXAC9IVRw), Shorts (https://www.youtube.com/shorts/jNQXAC9IVRw), directos (https://www.youtube.com/live/jNQXAC9IVRw), enlaces embed, móviles y de YouTube Music, y el identificador del video a secas (jNQXAC9IVRw). Un enlace entre comillas o paréntesis, o seguido de un punto, se limpia solo.

Los enlaces de canales y listas de reproducción devuelven unsupported_url, sin coste. Para canales enteros, listas de reproducción, búsquedas, filtros de fecha o «solo videos nuevos», mira «Herramientas de YouTube relacionadas».

Ejecútalo cada día o cada semana

Útil cuando la misma lista de videos se debe pedir una y otra vez, por ejemplo un conjunto fijo de videos para un informe semanal.

Rellena el formulario como lo quieras.
Haz clic en Save as a new task («Guardar como tarea nueva»), arriba a la derecha en la página del Actor. Una tarea es un formulario guardado con su propio botón Start. Aparece en Saved tasks («Tareas guardadas»).
Ejecuta la tarea una vez a mano: un Actor tiene que haberse ejecutado una vez antes de poder programarlo.
En el menú de la izquierda haz clic en Schedules («Programaciones») y luego en Create new («Crear nueva»).
En la tarjeta Schedule setup («Configuración de la programación») elige cada cuánto (una expresión cron o el constructor visual) y tu zona horaria. Next runs («Próximas ejecuciones») muestra cuándo se ejecutará.
En el desplegable Add («Añadir») elige tu tarea.
Haz clic en Enable («Activar»). Las programaciones nuevas empiezan desactivadas.

Para recibir los resultados después de cada ejecución, añade un webhook («aviso automático a otra aplicación») en la pestaña Integrations («Integraciones») de la tarea (evento ACTOR.RUN.SUCCEEDED), o deja que el nodo Apify Trigger de n8n o el módulo Watch Actor Runs de Make los recojan (los pasos están en «Integraciones»).

Este Actor pide exactamente los enlaces que le das. Para seguir un canal y recibir solo los videos nuevos desde la última ejecución, usa YouTube Scraper.

Usa la API de transcripciones de YouTube desde agentes de IA (MCP)

MCP es el estándar que permite a un asistente de IA usar herramientas externas. Apify tiene un servidor MCP alojado. Esta dirección le da al asistente este Actor como herramienta:

https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper

El inicio de sesión es OAuth: en la primera conexión se abre una ventana del navegador y no se guarda ningún token en la configuración. También sirve una cabecera Authorization: Bearer <YOUR_APIFY_TOKEN>. Cada llamada es una ejecución normal en tu cuenta de Apify y cuesta lo mismo que una que inicies tú. El asistente espera 30 segundos por ejecución de forma predeterminada (45 como máximo); un video tarda unos 3.

Claude.ai y Claude Desktop

Abre Settings («Configuración») y luego Connectors («Conectores»). En algunas versiones la página está en Customize («Personalizar»).
Haz clic en el botón de añadir y elige Add custom connector («Añadir conector personalizado»).
Rellena Name («Nombre»; por ejemplo YouTube transcripts) y Remote MCP server URL («URL del servidor MCP remoto»; la dirección de arriba). Haz clic en Continue («Continuar») y luego en Add («Añadir»).
Inicia sesión en Apify cuando el navegador te lo pida.
En un chat haz clic en +, luego en Connectors, y activa el conector.
- Verás: Claude pide permiso la primera vez que usa la herramienta, la ejecuta y responde a partir de la transcripción.

En el plan gratuito de Claude puedes añadir un conector personalizado. En los planes Team y Enterprise lo añade un propietario («Owner») para toda la organización.

Claude Desktop con un servidor local

claude_desktop_config.json, necesita Node.js:

{
  "mcpServers": {
    "youtube-transcripts": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "nokia2k/youtube-transcript-scraper"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}

Cursor

.cursor/mcp.json en tu proyecto, o ~/.cursor/mcp.json para todos los proyectos:

{
  "mcpServers": {
    "youtube-transcripts": {
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper"
    }
  }
}

Con un token en lugar de OAuth, añade "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" } junto a "url".

VS Code

Necesita GitHub Copilot. Abre la paleta de comandos, ejecuta MCP: Open User Configuration («abrir la configuración de usuario de MCP») y añade el servidor:

{
  "servers": {
    "youtube-transcripts": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper"
    }
  }
}

Claude Code

claude mcp add --transport http youtube-transcripts \
  "https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper" \
  --header "Authorization: Bearer $APIFY_TOKEN"

ChatGPT

Tiene que estar activado el modo Developer («modo de desarrollador»). Settings > Apps & Connectors > Create («Crear»); rellena Name, Description («Descripción») y MCP Server URL; pon Authentication («Autenticación») en OAuth; haz clic en Create. En un chat haz clic en +, luego en More («Más»), y elige el conector.

Ejemplos de peticiones

«Consigue la transcripción de https://www.youtube.com/watch?v=arj7oStGLkU y enumera las cinco ideas principales.»
«Trae los subtítulos en español de este video en SRT y dime cuántas líneas tienen: https://youtu.be/arj7oStGLkU»
«Lee las transcripciones de estos tres videos y haz una tabla comparativa de lo que recomienda cada ponente: [enlace 1] [enlace 2] [enlace 3]»

Integraciones: n8n, Make, Zapier, Python, JavaScript y LangChain

Tu token de API

La mayoría de las herramientas te piden tu API token («token de API»): una clave secreta que permite a otro programa usar tu cuenta de Apify. Está en la consola, en Settings y luego API & Integrations («API e integraciones»). Aquí se escribe <YOUR_APIFY_TOKEN>. No lo compartas nunca y no lo pongas en un archivo compartido ni en una dirección web.

API: una llamada con curl

Esta llamada inicia una ejecución, espera a que termine y devuelve las filas, una por video:

curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-transcript-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"], "outputFormats": ["text"]}'

Fíjate en la ~ entre el nombre de usuario y el nombre del Actor. Esta dirección espera como máximo 300 segundos y después responde HTTP 408; un video tarda unos 3. Para listas largas, inicia la ejecución con POST /v2/acts/nokia2k~youtube-transcript-scraper/runs, espera a que su estado sea SUCCEEDED y lee GET /v2/datasets/<DATASET_ID>/items?format=json&clean=true. Añade maxTotalChargeUsd para poner un tope al gasto; format también puede ser csv o xlsx.

Python

pip install apify-client (versión 3, Python 3.11 o posterior):

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nokia2k/youtube-transcript-scraper").call(
    run_input={
        "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
        "outputFormats": ["text", "srt"],
    },
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["status"] == "success":
        print(item["title"], item["wordCount"], "words")
        print(item["text"][:200])
    else:
        print(item["input"], "->", item["status"], item["message"])

JavaScript

npm install apify-client:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('nokia2k/youtube-transcript-scraper').call({
    videoUrls: ['https://www.youtube.com/watch?v=arj7oStGLkU'],
    outputFormats: ['text'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.status, item.status === 'success' ? item.text.slice(0, 200) : item.message);
}

Lee status en cada fila: la ejecución termina bien aunque un video no tenga transcripción.

LangChain

pip install langchain-apify langchain-core y define APIFY_API_TOKEN (la variable que lee langchain-apify):

from langchain_apify import ApifyWrapper
from langchain_core.documents import Document

loader = ApifyWrapper().call_actor(
    actor_id="nokia2k/youtube-transcript-scraper",
    run_input={
        "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
        "outputFormats": ["text"],
    },
    dataset_mapping_function=lambda row: Document(
        page_content=row.get("text") or "",
        metadata={
            "source": row.get("url"),
            "title": row.get("title"),
            "status": row.get("status"),
        },
    ),
)
docs = [d for d in loader.load() if d.metadata["status"] == "success"]

Para que un agente llame al Actor por sí mismo, usa ApifyActorsTool("nokia2k/youtube-transcript-scraper").

n8n: entra un video, sale la transcripción

En n8n una automatización es un «flujo de trabajo» y cada paso, un «nodo».

Instala el nodo de Apify. En n8n Cloud: abre el panel de nodos, busca Apify (aparece en More from the community, «Más de la comunidad») e instálalo; tiene que hacerlo un propietario o administrador. En tu propio servidor: Settings > Community Nodes, Install, escribe @apify/n8n-nodes-apify, acepta los riesgos, Install. Hace falta n8n 1.57.0 o posterior.
Añade el nodo Apify después del nodo que te da el enlace (un formulario, un webhook, una fila de una hoja). Pon Resource («Recurso») en Actor y Operation («Operación») en Run an Actor and Get Dataset («Ejecutar un Actor y obtener los resultados»).
Conecta tu cuenta: credencial Apify API, con el token en API Key. En n8n Cloud también sirve Apify OAuth2 API con Connect my account («Conectar mi cuenta»).
En Actor, selecciona nokia2k/youtube-transcript-scraper.
En Input JSON, pega la entrada de un video de «Ejemplos de entrada» y pon {{ $json.url }} en lugar del enlace, sin quitar las comillas. Esa expresión de n8n toma el enlace del nodo anterior; usa el nombre de campo que tenga tu nodo. Opcional: Maximum Cost per Run (USD) («Coste máximo por ejecución»).
Ejecuta el nodo.
- Verás: un elemento por video con status, title y text. Usa {{ $json.text }} en el nodo siguiente.

Conviene saber:

¿Salida vacía o rara? Elegiste Run an Actor, que devuelve la descripción de la ejecución. Usa Run an Actor and Get Dataset.
Un video sin subtítulos no detiene el flujo. Continúa solo cuando status sea success; en otro caso, anota message.
Con el nodo HTTP Request: Method POST, URL https://api.apify.com/v2/acts/nokia2k~youtube-transcript-scraper/run-sync-get-dataset-items, Authentication con el tipo genérico Header auth (Name Authorization, Value Bearer <YOUR_APIFY_TOKEN>), Send Body activado, Body Content Type JSON, Specify Body Using JSON.

Make: dos módulos

En Make una automatización es un «escenario» y cada paso, un «módulo».

Añade el módulo de Apify Run an Actor («Ejecutar un Actor»). En Connection («Conexión»), inicia sesión en Apify o pega tu API token.
Elige este Actor en Actor, pon Run synchronously («Ejecutar de forma síncrona») en Yes (así Make espera el resultado), pega la entrada en Input JSON y asigna tu enlace dentro de ella.
Añade el módulo de Apify Get Dataset Items («Obtener los resultados»). En Dataset ID, asigna el defaultDatasetId del primer módulo. ¿Todavía no aparece en la lista? Ejecuta el escenario una vez y vuelve a mirar.
Añade el módulo que recibe el texto y asigna text, title y status.
- Verás: un resultado por video al ejecutar el escenario.

Con Run synchronously desactivado, el módulo siguiente lee un dataset vacío. Las ejecuciones síncronas en Make deben ser cortas: para cualquier cosa de más de unos 2 minutos, empieza con el disparador Watch Actor Runs («Vigilar ejecuciones del Actor») y sigue con Get Dataset Items. Si envías muchos videos, sube Limit («Límite») en Get Dataset Items.

Zapier: no pases de 30 segundos

Zapier corta una ejecución síncrona de un Actor a los 30 segundos y entonces la salida se pierde. Un video tarda unos 3 segundos, así que un video por ejecución del Zap es seguro.

Crea un Zap con tu disparador, por ejemplo una fila nueva en una hoja.
Añade la acción de Apify Run Actor. Conecta con Allow Access («Permitir acceso»), elige este Actor, pega la entrada, asigna el enlace y ejecútala de forma síncrona.
Añade la búsqueda de Apify Fetch Dataset Items («Traer los resultados») para leer las filas de esa ejecución.
Haz clic en Test step («Probar el paso»).
- Verás: los campos de la fila, text entre ellos, listos para tu siguiente acción.

Las listas largas necesitan dos Zaps. Zap A: tu disparador y después Run Actor (asíncrono). Zap B: el disparador Finished Actor Run («Ejecución del Actor terminada»), después Fetch Dataset Items y después tu destino.

Google Sheets y Excel

Excel: Export, Excel, Download.
Google Sheets a mano: exporta como CSV o Excel e importa el archivo en Sheets.
Google Sheets automáticamente: pon el paso de Google Sheets de Make, Zapier o n8n después de los pasos de Apify de arriba.
Google Drive después de cada ejecución: en la pestaña Integrations del Actor elige Upload results to GDrive, haz clic en Connect with Google, rellena Filename («nombre del archivo») y Format («formato») y haz clic en Save («Guardar»). Los archivos llegan a la carpeta Apify Uploads.

¿Cuánto cuesta conseguir transcripciones de YouTube?

Pagas por transcripción entregada. No hay suscripción.

Transcripción: $2.99 por cada 1000 con el plan Free en el momento de escribir esto, es decir, $0.00299 cada una. En los planes de pago de Apify sale más barato: $2.49 (Starter), $2.09 (Scale), $1.49 (Business). «Por cada 1000» es solo la forma de mostrar el precio: cada transcripción se cobra por separado, así que 37 transcripciones cuestan 37 × $0.00299 = $0.11.
Inicio de la ejecución: un evento propio de Apify, $0.00005 por ejecución por cada GB de memoria. Este Actor usa 1 GB por defecto, así que son $0.00005 por ejecución.
Nada más: ni uso de plataforma ni proxies. El precio que vale es el de la pestaña Pricing («Precios»).

Una ejecución con	Transcripciones entregadas	Transcripciones	Inicio	Total
10 videos	10	$0.0299	$0.00005	$0.02995
1000 videos	1000	$2.99	$0.00005	$2.99005
10 000 videos	10 000	$29.90	$0.00005	$29.90005

Los videos sin transcripción se restan: 100 videos de los que 12 no tienen subtítulos cuestan 88 × $0.00299 = $0.26. Una automatización que envía 50 videos al día, uno por llamada, durante 30 días hace 1500 ejecuciones: $4.485 por las transcripciones más $0.075 por los inicios, $4.56 en total.

Plan gratuito: Apify da $5 de crédito cada mes, sin tarjeta: unas 1600 transcripciones al mes a este precio. El crédito que no usas no pasa al mes siguiente.

Nunca se cobra: los videos sin subtítulos; los privados, borrados, de pago o con restricción de edad; las entradas que no son un video (incluidos los enlaces de canales y listas de reproducción); un video pegado dos veces (se pide una sola vez); las filas blocked y error; los videos a los que la ejecución no llegó; los formatos adicionales, los archivos de subtítulos, la traducción y los datos del video.

Pon un tope a una ejecución: antes de hacer clic en Start, abre Run options («Opciones de ejecución») y rellena Maximum cost per run («Coste máximo por ejecución»). El Actor se detiene al llegar a esa cantidad y dice cuántos videos quedaron pendientes. En la API ese límite se llama maxTotalChargeUsd; en n8n, Maximum Cost per Run (USD).

Revisa lo cobrado: charged dice fila por fila qué se cobró. La página de cada ejecución muestra su importe, y Billing («Facturación») en la consola, el del mes.

Errores y solución de problemas

Qué significa cada estado

Mira status. Ninguna fila que no sea success se cobra.

`status`	Qué significa	Qué hacer
`success`	Transcripción entregada. El único estado que se cobra	Úsala. Un `message` aquí es una nota, por ejemplo sobre un cambio de idioma
`no_captions`	El video no tiene subtítulos de ningún tipo, ni escritos por una persona ni automáticos. O es un directo que sigue en marcha	No hay nada que obtener: el Actor no escucha el audio. Para un directo, vuelve a ejecutarlo unas horas después de que termine
`language_unavailable`	Hay subtítulos, pero no en los idiomas ni del tipo que permitiste, y la alternativa está desactivada	Lee `availableLanguages` y cambia `languages` o `captionType`, o activa la alternativa
`video_unavailable`	Borrado o nunca existió	Revisa el enlace
`video_unplayable`	Privado, de pago, bloqueado en la región o retirado por YouTube. `message` trae el motivo de YouTube	No se puede leer
`age_restricted`	YouTube solo lo muestra a adultos con sesión iniciada	No se puede leer
`blocked`	YouTube rechazó todas las conexiones que se probaron	Vuelve a ejecutarlo más tarde
`error`	Algo inesperado. `message` dice qué	Vuelve a ejecutarlo. Si se repite, abre una incidencia con el enlace de la ejecución
`invalid_input`	La entrada no es un enlace ni un identificador de YouTube, o estaba vacía	Copia otra vez el enlace de la barra de direcciones
`unsupported_url`	Un enlace de canal o de lista de reproducción	Pega los enlaces de los videos sueltos, o usa YouTube Scraper

Problemas y soluciones

«La ejecución terminó bien, pero una fila no tiene texto.» Lee su status y su message en la tabla de arriba. El motivo habitual es no_captions, frecuente en música y en videos sin voz.
«Recibí otro idioma del que pedí.» El video no tiene ninguno de tus idiomas y la alternativa está activada. language dice cuál recibiste y availableLanguages, cuáles existen. Desactiva la alternativa para omitir esos videos.
«El texto no tiene puntuación.» Viene de subtítulos automáticos (isAutoGenerated: true). Elige Human-made only en Caption type si necesitas puntuación; los videos sin esos subtítulos volverán gratis como language_unavailable.
«n8n me da una salida vacía o rara.» Usa Run an Actor and Get Dataset, no Run an Actor.
«Make lee un dataset vacío.» Pon Run synchronously en Yes, o usa Watch Actor Runs para ejecuciones largas.
«Zapier perdió el resultado.» Allí una ejecución síncrona se corta a los 30 segundos. Usa dos Zaps.
«Mi exportación tiene cientos de columnas.» Quita segments con Omit fields, o elige solo Plain text.
«Las filas no siguen el orden de mi lista.» Las filas llegan a medida que terminan los videos. Emparéjalas con input o videoId.
«Hay menos filas que enlaces.» Un video pegado dos veces recibe una sola fila. Un tope de gasto o un tiempo máximo detienen antes la ejecución; su mensaje final dice cuántos videos no se procesaron (esos son gratis).
«Un directo no tiene transcripción.» La tiene cuando ha terminado y YouTube ha procesado la grabación: normalmente unas horas, hasta un día en directos largos, y algunas grabaciones nunca reciben subtítulos.

Límites que conviene conocer

No transcribe audio. Lee los subtítulos que existen en YouTube.
No lee videos con restricción de edad, privados ni solo para miembros.
Solo enlaces de videos. No canales, listas de reproducción ni búsquedas: mira «Herramientas de YouTube relacionadas».
Sin fecha de publicación, «me gusta», comentarios ni «no me gusta» en este Actor. YouTube no muestra los «no me gusta» a nadie.
La traducción es la de YouTube. translateTo depende de que YouTube ofrezca su traducción automática para ese video.
Sin tiempos por palabra. Los tiempos son por línea de subtítulo.
Una fila tiene un límite de tamaño. En un video extremadamente largo, los formatos más grandes se quedan fuera de la fila, empezando por vtt y srt, y message dice cuáles. El texto plano se conserva.

Preguntas frecuentes

¿Por qué un video de YouTube volvió sin transcripción?

La fila dice por qué: status en una palabra y message en una frase. El motivo habitual es no_captions, frecuente en música y en videos sin voz.

¿Me cobran cuando un video no tiene transcripción?

No. Solo se cobran las filas success, y charged vale true solo en esas.

¿Qué significa «por cada 1000» y cuánto costará mi ejecución?

Con el plan Free, $2.99 pagan 1000 transcripciones en el momento de escribir esto, así que cada una cuesta $0.00299 (desde $1.49 por cada 1000 con los planes de pago). 200 transcripciones cuestan alrededor de $0.60, más $0.00005 por cada inicio de ejecución. Mira la tabla de «¿Cuánto cuesta conseguir transcripciones de YouTube?».

¿Puedo obtener la transcripción de los Shorts de YouTube?

Sí. Pega el enlace youtube.com/shorts/.... Un Short tiene transcripción cuando tiene subtítulos.

¿Puedo obtener la transcripción de un directo de YouTube?

Sí, cuando el directo ha terminado y YouTube ha procesado la grabación. Hasta entonces recibes no_captions, sin coste. Se aceptan los enlaces youtube.com/live/....

¿Puedo obtener las transcripciones de un canal entero o de una lista de reproducción?

No con este Actor: ese enlace devuelve unsupported_url, sin coste. YouTube Scraper enumera por sí mismo los videos de un canal o de una lista.

¿Qué idioma recibo y puede traducir los subtítulos de YouTube?

El idioma en que se habla el video, salvo que indiques otros idiomas por orden de preferencia. translateTo pide la traducción automática de YouTube. Si recibiste un idioma que no pediste, el video no tiene ninguno de los tuyos y la alternativa está activada: message lo indica.

¿Transcribe el audio cuando un video no tiene subtítulos?

No. Lee los subtítulos que ya existen en YouTube.

¿Me bloqueará YouTube? ¿Necesito un proxy o una clave de API de YouTube?

No hay nada que configurar: ni proxy, ni clave de API, ni inicio de sesión. Se prueban dos identidades de aplicación distintas y tres tipos de conexión antes de dar un video por blocked. En la prueba del 8 de octubre de 2026, YouTube bloqueó 0 de 3629 videos. Una fila blocked es gratuita: vuelve a ejecutarla más tarde.

Mi ejecución no muestra datos. ¿Dónde están mis resultados?

En la pestaña Output de la ejecución; las anteriores están en Runs («Ejecuciones») en el menú de la izquierda. En n8n usa Run an Actor and Get Dataset; en Make pon Run synchronously en Yes. Una entrada vacía da una fila invalid_input.

¿Por qué falta un campo o está vacío?

Los campos de la transcripción solo aparecen para los formatos elegidos y en las filas success. files necesita saveFiles; data necesita la entrada videoUrl. Los datos del video están vacíos si Include video details está desactivado.

¿Puedo filtrar videos por fecha o recibir solo los nuevos?

Aquí no: pide exactamente los enlaces que le das. YouTube Scraper limita por fecha los videos de un canal y puede entregar solo los videos nuevos desde la última ejecución.

¿Por qué tengo menos filas que enlaces?

Un video pegado dos veces recibe una sola fila. Los videos a los que la ejecución no llegó, por un tope de gasto o un tiempo máximo, no tienen fila ni coste; el mensaje final de la ejecución dice cuántos.

¿Hay un nodo de transcripción de YouTube para n8n?

Sí. Instala el nodo verificado de Apify para n8n, elige Run an Actor and Get Dataset y selecciona este Actor: cada ejecución devuelve la transcripción en unos 3 segundos. Un flujo que ya envía videoUrl y targetLanguage a otro Actor de transcripciones sigue funcionando si lo cambias por este, porque la entrada y la lista data son las mismas. Los videos sin subtítulos no cuestan nada.

¿Cómo envío transcripciones de YouTube a n8n, Make, Zapier o Google Sheets?

Sigue los pasos de «Integraciones». n8n: Run an Actor and Get Dataset. Make: Run an Actor y después Get Dataset Items. Zapier: Run Actor y después Fetch Dataset Items. Sheets: Export como Excel o CSV.

¿Pueden usarlo ChatGPT o Claude?

Sí, mediante MCP. Añade https://mcp.apify.com?tools=nokia2k/youtube-transcript-scraper como conector y pide la transcripción de un video con tus propias palabras. Los pasos están en «Usa la API de transcripciones de YouTube desde agentes de IA».

¿Qué significan las marcas de tiempo? ¿SRT o VTT?

Una marca de tiempo es el momento del video en que se dice una línea: segundos desde el principio en segments, [MM:SS] en timestampedText. SRT va bien para editores de video y la mayoría de los reproductores; VTT, para video en páginas web.

¿Puedo obtener comentarios, «me gusta» o la fecha de publicación?

Aquí no. YouTube Scraper añade la fecha exacta de publicación, los «me gusta», comentarios, capítulos y más.

¿Cuántos videos por ejecución y cuántas ejecuciones a la vez?

No hay un número fijo de videos por ejecución; se procesan 40 a la vez. Cuántas ejecuciones puedes tener al mismo tiempo depende de tu plan de Apify, por ejemplo 32 en Starter, 128 en Scale y 256 en Business.

¿Qué pasa si una ejecución se interrumpe o llega a su tiempo máximo?

Las filas se guardan una a una, así que no se pierde nada de lo entregado. Cerca del tiempo máximo, la ejecución deja de tomar videos nuevos, termina con normalidad y dice cuántos quedan. Si Apify traslada la ejecución a otro servidor, continúa donde se quedó y no cobra ningún video dos veces. El único caso que termina como fallido: tras ese traslado no se pueden volver a leer los resultados anteriores, así que la ejecución se detiene antes de pedir nada para no arriesgarse a cobrar un video dos veces.

¿Es legal descargar transcripciones de YouTube? ¿Y los videos privados y los «no me gusta»?

El Actor lee solo lo que YouTube muestra públicamente a cualquier visitante. Lo que hagas con los textos es responsabilidad tuya: respeta los derechos de autor y las condiciones de YouTube. Los videos privados, solo para miembros o con restricción de edad no se pueden leer, y los «no me gusta» no están disponibles.

¿Qué significan Actor, ejecución, dataset y token de API?

Actor: el nombre que da Apify a una herramienta lista para usar que funciona en la nube.
Ejecución (run): cada vez que un Actor trabaja, desde Start hasta el final.
Dataset («conjunto de resultados»): la tabla donde una ejecución guarda sus resultados. Es lo que muestra la pestaña Output.
Key-value store («almacén de archivos»): donde una ejecución guarda archivos, como los subtítulos de saveFiles.
API y token de API: una forma de que un programa inicie una ejecución y lea sus resultados, y la clave secreta que demuestra que el programa actúa en nombre de tu cuenta.
JSON: un formato de texto para datos: nombres y valores entre llaves.
Subtítulos y transcripción: los subtítulos son las líneas de texto que YouTube muestra sobre un video; la transcripción es todas ellas como un solo texto.
Subtítulos automáticos: los crea el reconocimiento de voz de YouTube. Existen para muchos más videos, pero pueden tener errores y, en muchos idiomas, no llevan puntuación.
SRT y VTT: tipos de archivo de subtítulos: líneas de texto con hora de inicio y de fin.
Pago por evento: se cobra por resultado entregado, no por mes.
MCP: el estándar que permite a asistentes de IA como Claude y ChatGPT usar herramientas externas.

Algo salió mal. ¿Dónde consigo ayuda?

En la pestaña Issues («Incidencias») de este Actor. Mira «Soporte y actualizaciones».

Herramientas de YouTube relacionadas

Tres Actors del mismo desarrollador, cada uno pensado para un punto de partida distinto: elige el que encaje con lo que tienes. Precios por cada 1000 resultados en el momento de escribir esto.

Actor	Úsalo cuando tienes	Recibes	Precio
YouTube Video to Text 📝	Una lista grande de enlaces de videos, una lista de reproducción o un canal	Solo texto plano, el precio más bajo	$1.99
YouTube Transcript Scraper ⚡ (estás aquí)	Enlaces de videos, y alguien está esperando	Texto, marcas de tiempo, SRT, VTT y traducción, en unos 3 s	$2.99
YouTube Scraper 🧰	Enlaces, un canal, una lista o un tema, y necesitas cifras	Transcripción más «me gusta», comentarios, capítulos y datos del canal	$4.99

Soporte y actualizaciones

¿Algo no funciona como se describe, o falta un campo? Abre una incidencia en la pestaña Issues de este Actor. Incluye el enlace de la ejecución (cópialo de la barra de direcciones con la ejecución abierta), el enlace del video y lo que esperabas.

Última actualización: octubre de 2026.

Consigue tu primera transcripción: pega un enlace y haz clic en Start.

YouTube Transcript & Subtitles Scraper API

johnvc/YoutubeTranscripts

Scrape YouTube transcripts, subtitles, and captions in bulk, the cheapest pay-per-video YouTube transcript API on Apify. Callable from any MCP client (Claude, Cursor, ChatGPT). Supports YouTube videos, Shorts, and every URL format.

John

4.9K

4.5

(10)

YouTube Video Transcript & Metadata Scraper

trisecode/yt-transcript

Fast & free YouTube scraper. Extract transcripts, subtitles, and detailed video metadata without an API key. Supports export to JSON, CSV.

Trisecode

122

Youtube Transcript - 1$/month

insight_api_labs/youtube-transcript

Youtube Transcript (with video details and transcript timestamps)

InsightAPILabs

942

3.1

(3)

YouTube Transcript Scraper

seemuapps/youtube-transcript-scraper

Extract full transcripts and timestamped captions from any YouTube video in your chosen language and export them as JSON or CSV.

Seemu Scraping

5.0

(1)

YouTube Transcript with Translation (VidScribe)

kelvinosse/youtube-transcript-with-translation

Extract subtitles & captions from any YouTube video in seconds. Supports auto-generated and manual captions in 150+ languages. Optionally translate transcripts into 30 languages using AI. Output as JSON, plain text, or SRT subtitle files.

Kelvin

Youtube Transcript API

transcriptdev/youtube-transcript-api

YouTubeTranscript.dev turns YouTube videos into text. It uses captions in 100+ languages and AI transcription when captions are missing. Supports single videos and batches, TXT/SRT/VTT/JSON export, translation, and a REST API.

Youtube Transcript Dev

YouTube Transcript Scraper

parsebird/youtube-transcript-scraper

Get YouTube video transcripts and subtitles at scale. Extract plain text, timestamped segments, SRT and VTT, plus title, channel, views, and keywords. Optional Whisper AI fallback for caption-less videos.