YouTube Channel Transcripts Scraper 📚 Channel to Text

Paste one YouTube channel, @handle or playlist link and get the transcript of every video, with exact publish date and likes, plus one Markdown file of all of them for ChatGPT, Claude, NotebookLM or your knowledge base.

$9.99 per 1,000 transcripts at the time of writing, about one cent each.

Videos that fail or have no captions are never charged.

🇪🇸 Guía completa en español

What does YouTube Channel Transcripts do?

This Actor (Apify's word for a ready-made tool that runs in the cloud) lists the videos of the channel or playlist for you, reads the captions YouTube keeps for each one, written by a person or automatic, and writes everything into a table and into one file, ALL_TRANSCRIPTS.md. You do not copy video links one by one and you do not paste transcripts one by one. There is no YouTube API key to get, no login and no proxy to set up.

Why people pick it

• One link, the whole channel. Paste a channel link, an @handle or a playlist link and the videos are listed for you, newest first: up to 5,000 per channel or playlist, filtered by date and by kind (regular videos, Shorts, live recordings).
• One file for your AI tool. Every run writes ALL_TRANSCRIPTS.md: every video under its own heading with channel, date and link, ready for ChatGPT, Claude, NotebookLM or a company knowledge base.
• Exact date and likes on every row. YouTube's lists say "3 weeks ago"; each row here has the exact publish date and time, the like count, the category and whether it is a Short.
• Only new videos on a schedule. Run it every day or week and each run delivers, and charges, only the videos it has not delivered before.
• Fast on big channels. 1,800 videos from 18 channels took 77 seconds with the default 4 GB of memory, at no extra cost.
• You pay for transcripts, not for misses. A video without captions is a free row with its reason, and a run always ends as Succeeded.

Measured speed and reliability

Total run time from start to finish on the Apify platform, 7–8 October 2026:

• The 5 newest videos of a channel: 6.6 seconds.
• 1,800 videos from 18 channels: 77 seconds with 4 GB of memory. The same job took 5.5 minutes with 1 GB.

That second line is why the default memory is 4 GB. Memory is how much working room Apify gives the run; more room lets many videos be handled at the same time. It costs you nothing extra, because the price is per transcript, not per minute or per GB (only the start fee grows, to $0.0002).

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, 1 failed on a timeout (0.03 %) and 0 blocked by YouTube. 25 difficult videos (no captions, live, age-restricted, private, deleted, paid, blocked in the US, a 5-hour video, Japanese, Korean, Spanish, Shorts) each got the right answer. A run ends as Succeeded with one row per video that says what happened; an unexpected problem becomes a row with status: "error", not a failed run, so an automation does not break.

Quick start: get all transcripts of a YouTube channel in 5 steps

You need a web browser. Nothing is installed on your computer.

1. Create a free Apify account. Open https://console.apify.com/sign-up. Type your email and a password of 8 characters or more and click Sign up, then click the link in the verification email. Or click Continue with Google, which needs no verification.
   • You see: Apify Console, the web panel where Actors are run. The free plan gives you $5 of credit every month and asks for no credit card.
2. Open the Actor. Go to https://apify.com/nokia2k/youtube-channel-transcripts and click Try for free. If you do not arrive at the form, open Apify Store in the left menu of Console, search for "YouTube Channel Transcripts" and click it.
   • You see: the Input tab. The first field, 📺 Channels, playlists or videos, holds an example, https://www.youtube.com/@TED. The second, 🔢 Videos per channel or playlist, shows 5.
3. Paste your channel. Replace the example with your channel: open it on YouTube and copy the address from the address bar. Keep 5 videos for this first try (it uses about 5 cents of the free credit).
4. Click Start.
   • You see: the page of the run (one execution of the Actor). A status line reports progress, for example "5/5 videos checked, 5 transcripts delivered". It ends as Succeeded with a line such as "Done. 5 transcripts delivered."
5. Open the Output tab, click Export, choose a format and click Download. Excel, CSV, JSON, XML, HTML table, RSS or JSONL; Preview shows the result first.
   • You see: first a table with one row per video: Thumbnail, Title, Status, Language, Auto-generated, Duration (s), Words, Transcript, Channel, Views, Found in, Published, Likes, Video and Message. This table is the dataset, the list of results of the run. After Download the file is in your Downloads folder.

The one-file version is on the run's Storage tab, under Key-value store: see Download ALL_TRANSCRIPTS.md.

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

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 5
}

What data do you get from each video?

Every output field

One row per video. Transcript fields appear only for the formats you chose and only on success rows.

Field	Meaning	Example
Outcome
status	What happened with this video	success
message	The reason when there is no transcript, or a note	""
charged	Whether this row was charged	true
input	The link this row was made from	https://www.youtube.com/watch?v=arj7oStGLkU
scrapedAt	When the row was made (UTC)	2026-10-08T09:00:00+00:00
The video
videoId, url	The 11-character ID and the link of the video	arj7oStGLkU
title	Title	Inside the Mind of a Master Procrastinator | Tim Urban | TED
channelName, channelId	Channel and YouTube's ID of the channel	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
Date, likes and kind
publishedAt	Exact date and time of publication	2016-04-06T09:59:35-07:00
likeCount	Exact number of likes (empty when the owner hides them)	2054977
category	YouTube's category	People & Blogs
isShort	True for Shorts	false
liveStartedAt, liveEndedAt	For live streams: when the stream started and ended
Where it was found (videos from a channel or playlist)
source	The channel or playlist link you pasted	https://www.youtube.com/@TED
sourceType	channel or playlist	channel
sourceTitle	Name of the channel or playlist	TED
positionInSource	Place in the list, starting at 1	1
publishedText	The age as YouTube's list shows it	2 hours ago
Language
language, languageName	Language of the transcript you received	en, English
isAutoGenerated	True when YouTube's speech recognition wrote the captions	false
isTranslated, translatedFrom	Whether it is a machine translation, and from which language	false
availableLanguages	Every caption language the video has (code, name, isAutoGenerated, isTranslatable)
The transcript
text	The whole transcript as one paragraph	So in college, I was a government major, …
timestampedText	One line per caption: [MM:SS] text
segments	Lines with start, duration, end (seconds) and text
srt, vtt	The content of a subtitle file
markdown	The video as a Markdown document	see the sample below
files	Download links, when saveFiles is on
data	Caption lines as start, dur, text; only when the input used the single videoUrl field
segmentCount, wordCount, charCount	Lines, words and characters of the transcript	315, 2277, 12671

Sample output: one success row and one no_captions row

A video pasted directly, with the formats text and markdown. Real values of 8 October 2026; long values are shortened with "…".

{
    "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,
    "publishedAt": "2016-04-06T09:59:35-07:00",
    "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",
    "category": "People & Blogs",
    "likeCount": 2054977,
    "isShort": false,
    "liveStartedAt": null,
    "liveEndedAt": null,
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "markdown": "# Inside the Mind of a Master Procrastinator | Tim Urban | TED\n\n- Channel: TED\n- Published: 2016-04-06\n- URL: https://www.youtube.com/watch?v=arj7oStGLkU\n- Language: English\n\nSo in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}

A video found through a channel has five more fields. These come from a real run of @TED:

{
    "source": "https://www.youtube.com/@TED",
    "sourceType": "channel",
    "sourceTitle": "TED",
    "positionInSource": 1,
    "publishedText": "2 hours ago"
}

A video without captions found in the same channel. The ID and the title are placeholders here; the other values are 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": [],
    "wordCount": 0,
    "source": "https://www.youtube.com/@TED",
    "sourceType": "channel",
    "charged": false
}

Download ALL_TRANSCRIPTS.md, the one-file knowledge base

1. On the page of the run, open the Storage tab. It has three parts: Dataset, Key-value store and Request queue.
2. Open Key-value store: a small folder of files that belongs to the run.
   • You see: a list of names. One of them is ALL_TRANSCRIPTS.md.
3. Use the download control in its row. Open the file with any text editor (Notepad on Windows, TextEdit on a Mac): Markdown is plain text with a few marks for headings and lists.

What is inside: every video that has a transcript, one after the other, separated by a line. Each video looks like the markdown value in the sample: a heading with the title, then the lines Channel, Published, URL and Language, then the transcript in paragraphs of about one minute. Videos without a transcript are not in the file; they are in the table with their reason.

A large run is split into files of about 8 MB, named ALL_TRANSCRIPTS_1.md, ALL_TRANSCRIPTS_2.md and so on: download them all. The Log tab of the run names the files in a line that begins "All transcripts in one place". The combined files of one run hold at most about 60 million characters; beyond that the transcripts are in the table only. The file is free: it does not change the price.

Then give it to your AI tool:

• NotebookLM: open or create a notebook and add the file as a source.
• ChatGPT: attach the file to a chat, or add it to the files of a project or of a custom GPT.
• Claude: attach the file to a chat, or add it to the knowledge of a project.
• A company knowledge base: import the file. If your system prefers one document per video, turn on 💾 Also save subtitle files I can download and add the Markdown format: you then get one .md file per video.

Download soon: on the free plan an unnamed dataset is deleted after 7 days.

Use cases

• Turn a whole channel into a ChatGPT, Claude or NotebookLM knowledge base in one file, and ask what the creator said about any topic, with video and date.
• Archive your own channel as searchable text for your website, a course or a book.
• Study a creator or a competitor: what they talk about, how often they publish, which videos get the most likes.
• Keep a knowledge base up to date by itself: a daily schedule adds only the videos published since the last run.
• Turn a playlist of lessons into course notes, in the original language or translated.
• Feed a RAG pipeline with one row per video, exact dates and one-minute text blocks for precise citations.

Input examples

Every input field

The fields are listed in the order of the form, with the name used in JSON.

📺 Channels, playlists or videos (urls). What you want read. One link per line; you can mix kinds.

You paste	You get
a channel: https://www.youtube.com/@TED or just @TED	the channel's videos, newest first
a channel tab: https://www.youtube.com/@TED/shorts (also /videos, /streams)	only that kind, for that channel
a playlist: https://www.youtube.com/playlist?list=PL...	the videos of the playlist, in playlist order
a video: https://www.youtube.com/watch?v=arj7oStGLkU, a youtu.be link, a Shorts link or the 11-character ID	that one video

A video link that also names a playlist (watch?v=...&list=...) counts as that single video. To get the whole playlist, paste the playlist link.

Field in the form (JSON name)	What it is	Example
🔢 Videos per channel or playlist (maxVideosPerSource)	The most videos taken from each channel or playlist. The form opens with 5 so that a first test is cheap; if the field is left out (for example in an API call) the value is 50. Maximum 5,000. Three channels with 100 each can give up to 300 rows.	100
🌐 Transcript language (languages)	Leave it on "🎬 Original language of the video (recommended)" and each video comes back in the language it is spoken in. Or pick languages in order of preference from the list of 70; the first one the video has is used. You can also type a code (pt-BR) or a name (Spanish, español). Captions written by people are preferred.	["es", "en"]
📄 Output formats (outputFormats)	How each transcript is returned: segments, text, timestampedText, srt, vtt, markdown (a document with title, channel, date and link). Pick any number; the price does not change. Without a choice you get segments and text.	["text"]
📚 Also give me everything as one Markdown file (combinedFile)	On by default. Writes ALL_TRANSCRIPTS.md to the run's key-value store.	true
💾 Also save subtitle files I can download (saveFiles)	Off by default. One file per video for each text format you selected (.txt, .srt, .vtt, and .md when Markdown is selected), with download links in files.	true
📅 Only videos newer than (newerThan)	Empty means no limit. A date (2026-04-01) or an age (30 days, 6 months). Approximate, see below.	"6 months"
Only new videos since the last run (onlyNewVideos)	For scheduled runs: each run delivers only videos it has not delivered before for the same channels and playlists. Off by default. See Run it on a schedule.	true
Memory name (stateKey)	Optional, used only with the field above: the name of the list of delivered videos.	"my-daily-news"
🎞️ Kinds of videos to take from a channel (contentTypes)	Regular videos (videos), Shorts (shorts), recordings of live streams (streams). All three are ticked at first. Applies to channels, not playlists.	["videos"]
🔁 Translate to (translateTo)	YouTube's own machine translation into that language, used only when the video has no captions in it. YouTube does not offer it for every video; then you get the original language and a note in message.	"es"
If my language is missing, give me the original language (fallbackToAnyLanguage)	On by default. Turn it off to skip videos that lack your languages; skipped videos are free.	false
Caption type (captionType)	"Any, human-made first" (any), "Human-made only" (manual) or "Auto-generated only" (auto). Automatic captions often have no punctuation.	"manual"
Merge caption lines into blocks (mergeSegmentsSeconds)	Joins YouTube's short caption lines into blocks of about this many seconds. 0 keeps the original lines.	30
Include video details (includeMetadata)	On by default: channel, duration, views, description, keywords and thumbnail. Keep it on for the knowledge file: the channel name in each heading comes from here.	true

A whole channel, newest first

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 200,
    "outputFormats": ["text"]
}

A batch: two channels, 20 videos each

{
    "urls": ["https://www.youtube.com/@TED", "@anotherchannel"],
    "maxVideosPerSource": 20,
    "outputFormats": ["text"]
}

A playlist, Spanish if it exists, one Markdown file per video

{
    "urls": ["https://www.youtube.com/playlist?list=PLxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"],
    "maxVideosPerSource": 500,
    "languages": ["es", "auto"],
    "outputFormats": ["markdown"],
    "saveFiles": true
}

Translate a channel into one language

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 30,
    "translateTo": "es",
    "outputFormats": ["text", "markdown"]
}

Only the Shorts of the last 30 days

{
    "urls": ["https://www.youtube.com/@TED"],
    "contentTypes": ["shorts"],
    "newerThan": "30 days",
    "maxVideosPerSource": 200
}

Only new videos, for a daily schedule

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 50,
    "onlyNewVideos": true,
    "stateKey": "ted-daily",
    "outputFormats": ["text", "markdown"]
}

Six months of a channel in one knowledge file, step by step

1. Set the form. 📺 Channels, playlists or videos: your channel. 🔢 Videos per channel or playlist: 1000; this is a ceiling, not a target: the date decides how many videos are taken. 📄 Output formats: "Plain text (for reading and for AI)"; the Markdown file is written anyway. 📅 Only videos newer than: 6 months. 🎞️ Kinds of videos to take from a channel: untick Shorts and live recordings if you only want regular videos.

   {
       "urls": ["https://www.youtube.com/@TED"],
       "maxVideosPerSource": 1000,
       "newerThan": "6 months",
       "contentTypes": ["videos"],
       "outputFormats": ["text"],
       "combinedFile": true
   }
   

2. Put a ceiling on the spending. Expand Run options and type 5 in Maximum cost per run: five dollars cover about 500 transcripts. Leave Memory at 4 GB.

3. Click Start and watch. The status line first says that the videos are being listed, then counts, for example "60/120 videos checked, 55 transcripts delivered". The numbers are only an illustration: yours depend on the channel.

4. Check the table. Status tells you which videos have a transcript; Published shows the exact date of each video, so you can see where the six months end.

5. Download the knowledge file from Storage, Key-value store, and give it to your AI tool. Then ask in plain words: "What did this channel say about pricing in the last six months? Name the videos and their dates."

How exact is the date filter?

Close, but not to the day. When the Actor lists a channel, YouTube shows a rounded-down age for each video ("5 days ago", "3 weeks ago", "5 months ago"), not a date. A video marked "5 months ago" can be five months old or almost six. So the rule is: a video is kept whenever it can be new enough. Nothing newer than your limit is ever left out; a few videos just past the limit can slip in:

Age shown in YouTube's list	A video can be this much older than your limit and still get in
hours or days	less than a day
weeks	up to 6 days
months	up to about a month
years	up to a year

A video that slips in and has a transcript is delivered and charged like any other. Every row has the exact date in publishedAt: sort by it in Excel and delete the rows you do not want. If you type an age, a month counts as 30 days and a year as 365, from the day of the run; 6 months means 180 days back. For a precise start, pick a calendar date. A channel is listed newest first and reading stops soon after the limit is passed; a playlist is in the order its owner chose, so it is read to the end and then filtered.

Run it on a schedule and get only new videos

Follow a channel or a playlist and receive each new video once, automatically.

How "Only new videos since the last run" works

• Turn on Only new videos since the last run (onlyNewVideos). It is off by default and made for scheduled runs (Apify Schedules).
• Each run then delivers only the videos it has not delivered before for the same channels and playlists. Videos already delivered are left out before anything is fetched, so they are neither fetched nor charged.
• The first run delivers everything it finds and remembers it.
• Video links you paste directly are always delivered, never left out. They are remembered, so a channel that contains them later does not deliver them again.

Set it up step by step

1. Fill the form: your channels or playlists, 🔢 Videos per channel or playlist, your formats, and tick Only new videos since the last run. Optional: type a Memory name such as ted-daily.
2. Click Start once by hand. This first run delivers what it finds and remembers it. It also makes the Actor schedulable: an Actor must have run once before it can be scheduled.
3. Click Save as a new task at the top right of the Actor page. A task is a saved form; it appears under Saved tasks.
4. Open Schedules in the left menu and click Create new.
5. In the Schedule setup card choose how often (a cron expression such as @daily, or the visual builder) and your time zone. Next runs shows the coming dates.
6. In the Add dropdown pick your task.
7. Click Enable. New schedules start disabled.

What you see in later runs

• The log and the run's final status message say how many videos were left out, for example: "Skipped 37 videos already delivered in earlier runs (memory 'x')."
• A run with nothing new ends normally, with no rows: "No new videos since the last run: … Nothing was charged."

Memory name: one list or several

• Left empty: the memory is named auto-… after your list of channels and playlists. Any change to that list starts a new memory.
• With a name: you pick the record. The same name keeps one list of delivered videos even when the links change; a different name keeps a separate list.
• Letters, digits and -_.!'() are kept; other characters become -.

Where the memory lives and how to start afresh

The memory is kept in your own Apify account: Storage > Key-value stores, in the store named youtube-transcripts-memory. Each memory is one record that holds the IDs of the most recent 20,000 delivered videos and the time it was last updated. Delete the record, or the whole store, and the next run starts afresh and delivers everything again.

Good to know

• Remembered: videos delivered as success or no_captions. Everything else (blocked, error, age_restricted, a live stream that is still running or has not started) is tried again next run.
• Keep the number high enough. 🔢 Videos per channel or playlist counts the newest videos looked at in each run, before the known ones are left out. Set it above the number of videos the channel publishes between two runs.
• The memory is saved at the end of the run, also when the run stops before its time limit or at the spending cap (then only the videos that were processed). After a server move the run continues and saves at its end; nothing is counted or charged twice.
• If the memory cannot be read, the run logs a warning and delivers all videos like a normal run. If it cannot be saved, the results are still delivered, and the next run may repeat some videos.
• Two runs with the same memory at the same time can both deliver the same new video. The memory itself keeps the videos of both.

Send new videos to Google Sheets or Slack

• n8n: add the Apify Trigger node (Resource to Watch: Task, your task; Event Type: Succeeded). Then an Apify node with Resource Dataset, Get Items, and the defaultDatasetId of the run as Dataset ID (raise Limit: it starts at 50). Then a Google Sheets node that appends one row per item (title, url, publishedAt, likeCount, text), or a Slack node that posts title and url. A self-hosted n8n needs a public WEBHOOK_URL so that Apify can reach it.
• Make: start with Watch Actor Runs (it fires when a run finishes), then Get Dataset Items, then a Google Sheets module (Apify's guide uses "Bulk Add Rows") or a Slack module.
• Any other tool: on the task's Integrations tab add a webhook for the event ACTOR.RUN.SUCCEEDED. Apify sends a POST to your address; the dataset ID is in resource.defaultDatasetId. The receiver must answer within 2 minutes, and a webhook can arrive twice.

A run with no new videos still finishes as Succeeded, with an empty dataset: your sheet simply gets no new rows that day.

Use YouTube Channel Transcripts from AI agents (MCP)

MCP is a way for an AI assistant to use outside tools. This address gives the assistant this Actor as a tool:

https://mcp.apify.com?tools=nokia2k/youtube-channel-transcripts

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. The assistant waits at most 45 seconds for a run, then reads the results in a second step, so ask for a few videos at a time; for a whole channel, run it here and upload ALL_TRANSCRIPTS.md. Each run uses your Apify credit like any other.

Claude.ai and Claude Desktop

1. Open the Connectors page (Settings > Connectors, or Customize > Connectors, depending on your version).
2. Choose Add custom connector.
3. Fill Name and Remote MCP server URL with the address above, click Continue, then Add.
4. Sign in to Apify when the browser asks.
5. In a chat, click +, then Connectors, and switch the connector on.

On the free Claude plan you can add one custom connector. On Team and Enterprise plans an Owner adds it for the organization.

Claude Desktop with a local server

claude_desktop_config.json, needs Node.js:

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

Cursor

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

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

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:

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

Claude Code and ChatGPT

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

ChatGPT: Developer mode is needed. Go to Settings > Apps & Connectors > Create, fill Name, Description and MCP Server URL, choose OAuth under Authentication and click Create. In a chat, click +, then More, and pick the connector.

Example prompts

• "Get the transcripts of the 5 newest videos of @TED and summarize each in three bullet points."
• "Read the last 10 videos of this channel and tell me which topics come up most often, with the video and date for each: [channel link]"
• "Get the transcripts of this playlist and write a one-page study guide: [playlist link]"

Integrations: n8n, Make, Zapier, Python, JavaScript and LangChain

You need an API token for most of these: a secret key that lets another program use your Apify account. It is in Console under Settings, then API & Integrations. Treat it like a password. Below it is written as <YOUR_APIFY_TOKEN>. One warning for all of them: a whole channel can take longer than the short waiting time some tools allow; where that matters it is said in the steps.

API: one call with curl

In web addresses the Actor is written nokia2k~youtube-channel-transcripts. This call starts a run and returns the rows; it waits at most 300 seconds, and a longer run answers HTTP 408:

curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-channel-transcripts/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.youtube.com/@TED"], "maxVideosPerSource": 5, "outputFormats": ["text"]}'

For whole channels start the run with POST /v2/acts/nokia2k~youtube-channel-transcripts/runs, ask GET /v2/actor-runs/<RUN_ID> until the status is SUCCEEDED, then read GET /v2/datasets/<DATASET_ID>/items?format=json&clean=true. The combined file is a record of the run's key-value store, whose ID is in the same run data:

curl -L "https://api.apify.com/v2/key-value-stores/<STORE_ID>/records/ALL_TRANSCRIPTS.md" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -o ALL_TRANSCRIPTS.md

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-channel-transcripts").call(
    run_input={
        "urls": ["https://www.youtube.com/@TED"],
        "maxVideosPerSource": 200,
        "newerThan": "6 months",
        "outputFormats": ["text"],
    },
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["status"], item.get("publishedAt"), item.get("title"))

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-channel-transcripts').call(
    { urls: ['https://www.youtube.com/@TED'], maxVideosPerSource: 200, newerThan: '6 months' },
    { maxTotalChargeUsd: 5 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((item) => item.status === 'success').length, 'transcripts');

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-channel-transcripts",
    run_input={
        "urls": ["https://www.youtube.com/@TED"],
        "maxVideosPerSource": 20,
        "outputFormats": ["text"],
        "combinedFile": False,
    },
    dataset_mapping_function=lambda row: Document(
        page_content=row.get("text") or "",
        metadata={
            "source": row.get("url"),
            "title": row.get("title"),
            "publishedAt": row.get("publishedAt"),
            "status": row.get("status"),
        },
    ),
)
docs = [d for d in loader.load() if d.metadata["status"] == "success"]

n8n

1. Install the Apify node. On n8n Cloud: open the nodes panel, search Apify (under More from the community) and install it. Self-hosted: Settings > Community Nodes, Install, package @apify/n8n-nodes-apify.
2. Create the credential Apify API and paste your token into API Key.
3. Add the node Apify. Choose Resource Actor and Operation Run an Actor and Get Dataset.
4. In Actor choose YouTube Channel Transcripts. In Input JSON paste, for example: {"urls": ["https://www.youtube.com/@TED"], "maxVideosPerSource": 20, "outputFormats": ["text"]}.
5. Set Memory to 4096. The node sends 1024 unless you change it, and large channels are much slower with that. Optionally set Maximum Cost per Run (USD).
6. Execute.
   • You see: each video as one n8n item; connect the next node.
7. For the Markdown file, use the operation Run an Actor instead: it returns the data of the run, with the ID of the dataset (defaultDatasetId) and the ID of the key-value store. Read the table with Resource Dataset, Get Items (raise Limit: it starts at 50), and the file with Resource Key-Value Store, Get Key-Value Store Record, giving that store and the name ALL_TRANSCRIPTS.md.

Make

1. Add the module Run an Actor. Fill Connection, Actor and Input JSON, set Memory to 4096 and set Run synchronously to Yes.
2. Add Get Dataset Items and map Dataset ID to the defaultDatasetId of the first module. Raise Limit so that all rows arrive.
3. Add your destination, for example a Google Sheets module.

A synchronous run in Make is safe only up to about 2 minutes. For a whole channel use the other pattern: start the run from Console or a schedule, and build the scenario from the trigger Watch Actor Runs followed by Get Dataset Items.

Zapier

Zapier waits only 30 seconds for a synchronous run, then the result is lost. A handful of videos fits; a channel does not. Use two Zaps:

1. Zap A: your trigger, then the action Run Actor, set to run asynchronously.
2. Zap B: the trigger Finished Actor Run, then Fetch Dataset Items, then your destination. Get Key-Value Store Record fetches ALL_TRANSCRIPTS.md.

Google Sheets and Excel

1. Excel: in the Output tab click Export, choose Excel, click Download. In the export window, Select fields lets you keep only some columns, for example title, publishedAt, likeCount, viewCount, url, text.
2. Google Sheets by hand: export as CSV or Excel and import that file in Sheets.
3. Google Drive, automatically: on the Actor's Integrations tab choose Upload results to GDrive, click Connect with Google, set Filename and Format and click Save. After each successful run the file appears in the folder Apify Uploads.

A long transcript in one spreadsheet cell is hard to read. For reading, use the Markdown file.

How much does it cost to get all transcripts of a YouTube channel?

The price is $9.99 per 1,000 transcripts at the time of writing. "Per 1,000" is only a way to print a small number: each delivered transcript costs $0.00999, about one cent, and is counted one by one. On top comes Apify's start fee: $0.00005 per run for each GB of memory, so $0.0002 for a run with the default 4 GB. Nothing else is billed for a run: no platform usage and no proxy fees. The price that counts for your plan is the one on the Actor's Pricing tab.

One run with	Transcripts delivered	Transcripts	Run start (4 GB)	Total
10 videos	10	$0.0999	$0.0002	$0.1001
1,000 videos	1,000	$9.99	$0.0002	$9.9902
10,000 videos	10,000	$99.90	$0.0002	$99.9002

Videos without a transcript are subtracted: 100 videos of which 12 have no captions cost 88 × $0.00999 = $0.88. With Only new videos since the last run you pay only for new videos: 30 daily runs that find 60 new videos in a month cost 60 × $0.00999 + 30 × $0.0002 = $0.6054.

What the free plan covers: $5 of credit each month, without a card. That is about 500 transcripts a month. Unused credit does not carry over.

Never charged: videos without captions; private, deleted, paid and age-restricted videos; videos YouTube refused or that failed; lines that are not YouTube links; channels or playlists that could not be listed; a video that appears twice (it is fetched once); videos left out because an earlier run delivered them; extra formats, the Markdown file, the subtitle files, translation, the date and the likes.

How to cap the spending: Run options, then Maximum cost per run. The Actor stops taking videos at that amount, ends the run normally and tells you how many videos were left. What was delivered stays, and the Markdown file is still written. In the API the limit is maxTotalChargeUsd; in n8n, Maximum Cost per Run (USD).

Errors and troubleshooting

What each status means

Look at the status of the row, then at its message.

status	In plain words	What to do
success	The transcript was delivered.	Nothing. This is the only status that is charged.
no_captions	The video has no captions at all, or it is a live stream that is still running.	Nothing can be fetched: the Actor does not listen to the sound. For a live stream, run it again some hours after it ends.
language_unavailable	The video has captions, but not in the languages or caption type you chose, and the fallback is off.	See availableLanguages. Turn the fallback on or change the language.
video_unavailable	The video was deleted or never existed.	Check the link.
video_unplayable	Private, paid, blocked in the region or removed by YouTube.	Read message: it carries 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.
invalid_input	The line is not a YouTube link or ID.	Correct the line.
source_problem	A channel or playlist could not be listed. message says why: a typing mistake in the name, a private playlist, a YouTube Mix, "Watch later" or "Liked videos", or no videos since your date.	Fix the link or widen the date.

Problems and solutions

• "Fewer videos than I asked for." The channel has fewer public videos, the date or kind filter left some out, a video was already in another list, scheduled videos were skipped, the memory left out videos delivered earlier, or the spending cap was reached.
• "Some videos are a little older than my date." The date filter is approximate; see How exact is the date filter?. Sort by publishedAt for an exact cut.
• "The rows are not in the channel's order." Many videos are handled at once, so rows arrive as they finish. Sort the table by publishedAt or by positionInSource.
• "My scheduled run delivered nothing." Read its final message: "No new videos since the last run" means the memory worked and nothing was charged.
• "My scheduled run delivered everything again." The list of channels changed without a Memory name (a new memory starts), or the memory record was deleted. Use a fixed Memory name.
• "My AI tool says the file is too big." Run the channel in parts (by date, or playlist by playlist), or turn on saveFiles with the Markdown format to get one file per video.
• "n8n is slow or gives odd output." Set Memory to 4096, and use Run an Actor and Get Dataset, not Run an Actor, for the rows.
• "Make or Zapier lost the result." Whole channels take longer than their synchronous limits. Use Watch Actor Runs (Make) or two Zaps.

Limits to know

• It does not listen to the sound. A video without any captions gives no_captions.
• No age-restricted, private or members-only videos, including your own private videos.
• No dislikes, and no comments or subscriber counts in this Actor.
• The date filter is approximate, as explained above.
• At most 5,000 videos per channel or playlist in one run.
• Some lists cannot be read: private playlists, a YouTube Mix, "Watch later" and "Liked videos".
• Videos that are scheduled but not yet published are skipped.
• The combined file has a ceiling of about 60 million characters per run. Beyond that the transcripts are in the table only.

FAQ

Why did a YouTube video come back without a transcript?

Most often it has no captions: music, clips without speech, or a language YouTube's speech recognition does not cover. The status and message of the row give the exact reason.

Am I charged when there is no transcript?

No. Only rows with the status success are charged. The charged field of every row says it too.

What does "$9.99 per 1,000" mean, and what will my channel cost?

It means $0.00999 per delivered transcript. Count the videos you expect and multiply by one cent: 300 videos are at most $3, plus $0.0002 per run.

Can I get the transcripts of a channel's Shorts?

Yes. A channel's Shorts are included unless you untick them, and isShort marks them. Paste https://www.youtube.com/@name/shorts to get only the Shorts.

Can I get the transcripts of live streams?

Recordings of finished streams work when YouTube has made captions for them, which can take from a few hours up to a day after the stream. A stream that is still running gives no_captions, free.

Can I mix channels, playlists and single videos?

Yes, in the same field, one per line. A video that appears in two of them is fetched once.

Which language do I get, and can it translate?

By default the language spoken in the video. You can set an order of preference, and 🔁 Translate to asks for YouTube's machine translation when the video offers it.

Does it transcribe the audio when there are no captions?

No. It reads captions that exist on YouTube.

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

There is nothing to set up: no proxy, no key. Two app identities and three kinds of connection are tried before a video is reported as blocked. In the test of 3,629 videos none was blocked. If it ever happens, the row says blocked, costs nothing and can be run again.

My run shows no data. Where are my results?

The table is in the Output tab of the run. The Markdown file is in Storage, then Key-value store. Earlier runs are under Runs in the left menu. On the free plan an unnamed dataset is deleted after 7 days; to keep one, open it and choose Rename in the Actions menu.

Why is a field missing or empty?

Transcript fields appear only for the formats you chose and only on success rows. The five "where it was found" fields exist only for videos that came from a channel or playlist. likeCount is empty when the owner hides the likes.

How does the date filter work and how exact is it?

It keeps every video that can be newer than your limit, judged by the rounded age YouTube's list shows. Nothing newer is lost; a few slightly older ones can slip in. Sort by publishedAt for an exact cut.

How do I get only the new videos of a channel every day?

Turn on Only new videos since the last run, run once, save the form as a task and schedule it. Steps in Run it on a schedule.

Why did I get fewer videos than I asked for?

The channel has fewer public videos, the date or kind filter left some out, a video was already in another list, scheduled videos were skipped, the memory left out videos delivered earlier, or the spending cap was reached.

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

See Integrations. For anything bigger than a few videos, use the pattern that does not wait.

Can ChatGPT or Claude use it?

Yes, through MCP, a few videos at a time. For a whole channel, run it here and upload the file.

What do the timestamps mean, and what are SRT and VTT?

A timestamp is the moment in the video when a line is spoken. SRT and VTT are two common subtitle file types that carry the lines with their times; video editors and web players read them.

Can I get comments, likes and the publish date?

Likes and the exact date are on every row. Comments are in YouTube Scraper.

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

Up to 5,000 videos from each channel or playlist, and as many links as you like. 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.

Can I archive my own channel?

Yes: paste your channel link. Public videos are read. Private ones are not, even though they are yours.

Is it legal to download a channel's transcripts?

The Actor reads what YouTube shows publicly to any visitor. What you do with the texts is your responsibility: respect copyright and YouTube's terms. Private videos and dislikes are not available.

What do Actor, run, dataset and key-value store mean?

• Actor: a ready-made tool on Apify.
• Run: one execution of an Actor, from Start to the result.
• Input: what you give the Actor: the form, or the same thing as JSON, a plain way to write settings as text.
• Dataset: the table of results of a run, one row per video.
• Key-value store: the folder of files of a run. ALL_TRANSCRIPTS.md is there.
• Markdown (.md): plain text with simple marks for headings and lists. AI tools read it well.
• API token: a secret key that lets another program use your Apify account.
• Captions and transcript: captions are the lines of text YouTube shows over a video; the transcript is all those lines together.
• Auto-generated captions: written by YouTube's speech recognition. They can contain mistakes and often have no punctuation.
• Handle: the name of a channel that starts with @.
• Task and schedule: saved settings of an Actor, and the timer that runs them.
• MCP: the way an AI assistant uses outside tools.
• Pay per event: you pay for each result, not for time.

Something went wrong. Where do I get help?

In the Issues tab of the Actor. See Support and updates.

Related YouTube tools

Six Actors by the same developer, each made for a different starting point: pick the one that matches what you have. Prices per 1,000 results at the time of writing.

Actor	Use it when you have	You get	Price
YouTube Video to Text 📝	A big list of video links	Plain text only, the lowest price	$1.99
YouTube Transcript Scraper ⚡	Video links, and someone is waiting	Text, timestamps, SRT, VTT, translation, in about 3 s	$4.99
YouTube Channel Transcripts 📚 (you are here)	A channel, @handle or playlist	Every video, publish date, likes, one Markdown file, only new videos	$9.99
YouTube Search Transcripts Scraper 🔎	A topic, no links	Transcripts of the videos YouTube ranks highest	$14.99
YouTube Scraper 🧰	Any of the above, and you need numbers	Transcript plus comments, chapters, hashtags, channel facts	$19.99
YouTube Transcript API 🚨	An app that needs one video right now	An always-on web address, no start-up wait	$99.00

Support and updates

Open an issue on the Issues tab of this Actor. Include the link of the run and the link of the channel or video, so the case can be repeated.

Last updated: October 2026.

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

🇪🇸 Guía completa en español

Pega un enlace de un canal de YouTube, un @handle o una lista de reproducción y recibe la transcripción de todos sus videos, con la fecha exacta de publicación y los «me gusta», más un archivo Markdown con todas ellas para ChatGPT, Claude, NotebookLM o tu base de conocimiento.

$9.99 por cada 1000 transcripciones en el momento de escribir esto, un centavo cada una, aproximadamente.

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) enumera por ti los videos del canal o de la lista, lee los subtítulos que YouTube guarda de cada uno, escritos por una persona o automáticos, y lo escribe todo en una tabla y en un archivo, ALL_TRANSCRIPTS.md. No copias enlaces uno a uno ni pegas transcripciones una a una. No hay que conseguir clave de API de YouTube, ni iniciar sesión, 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

• Un enlace, el canal entero. Pega un enlace de canal, un @handle o un enlace de lista de reproducción y los videos se enumeran solos, primero los más nuevos: hasta 5000 por canal o lista, filtrados por fecha y por tipo (videos normales, Shorts, grabaciones de directos).
• Un archivo para tu herramienta de IA. Cada ejecución escribe ALL_TRANSCRIPTS.md: cada video bajo su propio título con canal, fecha y enlace, listo para ChatGPT, Claude, NotebookLM o la base de conocimiento de tu empresa.
• Fecha exacta y «me gusta» en cada fila. Las listas de YouTube dicen «hace 3 semanas»; aquí cada fila tiene la fecha y la hora exactas de publicación, el número de «me gusta», la categoría y si es un Short.
• Solo videos nuevos, de forma programada. Ejecútalo cada día o cada semana y cada ejecución entrega, y cobra, solo los videos que no había entregado antes.
• Rápido en canales grandes. 1800 videos de 18 canales tardaron 77 segundos con los 4 GB de memoria por defecto, sin coste adicional.
• Pagas transcripciones, no fallos. Un video sin subtítulos es una fila gratuita con su motivo, y una ejecución siempre termina como Succeeded («completada»).

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:

• Los 5 videos más nuevos de un canal: 6.6 segundos.
• 1800 videos de 18 canales: 77 segundos con 4 GB de memoria. El mismo trabajo tardó 5.5 minutos con 1 GB.

Esa segunda línea es la razón de que la memoria por defecto sea de 4 GB. La memoria es el espacio de trabajo que Apify da a la ejecución; con más espacio se procesan muchos videos a la vez. No te cuesta nada más, porque el precio es por transcripción, no por minuto ni por GB (solo sube la tarifa de inicio, a $0.0002).

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 con restricción de edad, 1 fallido por tiempo agotado (0.03 %) y 0 bloqueados por YouTube. 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) recibieron cada uno la respuesta correcta. Una ejecución termina como Succeeded con una fila por video que dice qué pasó; un problema inesperado se convierte en una fila con status: "error", no en una ejecución fallida, así que una automatización no se rompe.

Inicio rápido: todas las transcripciones de un canal de YouTube en 5 pasos

Solo necesitas un navegador web. No se instala nada en tu computadora.

1. Crea una cuenta gratuita de Apify. Abre https://console.apify.com/sign-up. Escribe tu correo y una contraseña de 8 caracteres o más y haz clic en Sign up («Registrarse»); después haz clic en el enlace del correo de verificación. O haz clic en Continue with Google («Continuar con Google»), que no necesita verificación.
   • Verás: Apify Console («Consola de Apify»), el panel web donde se ejecutan los Actors. El plan gratuito te da $5 de crédito cada mes y no pide tarjeta.
2. Abre el Actor. Entra en https://apify.com/nokia2k/youtube-channel-transcripts y haz clic en Try for free («Probar gratis»). Si no llegas al formulario, abre Apify Store («tienda de Apify») en el menú de la izquierda de la consola, busca "YouTube Channel Transcripts" y haz clic en él.
   • Verás: la pestaña Input («Entrada»). El primer campo, 📺 Channels, playlists or videos («Canales, listas o videos»), trae un ejemplo, https://www.youtube.com/@TED. El segundo, 🔢 Videos per channel or playlist («Videos por canal o lista»), muestra 5.
3. Pega tu canal. Sustituye el ejemplo por tu canal: ábrelo en YouTube y copia la dirección de la barra de direcciones. Deja 5 videos para esta primera prueba (usa unos 5 centavos del crédito gratuito).
4. Haz clic en Start («Iniciar»).
   • Verás: la página de la ejecución (cada vez que el Actor trabaja). Una línea de estado informa del avance, por ejemplo "5/5 videos checked, 5 transcripts delivered". Termina como Succeeded con una línea como "Done. 5 transcripts delivered."
5. Abre la pestaña Output («Salida»), haz clic en Export («Exportar»), elige un formato y haz clic en Download («Descargar»). Excel, CSV, JSON, XML, HTML table, RSS o JSONL; Preview («Vista previa») te enseña el resultado antes.
   • Verás: primero una tabla con una fila por video: Thumbnail («Miniatura»), Title («Título»), Status («Estado»), Language («Idioma»), Auto-generated («Automático»), Duration (s) («Duración, en segundos»), Words («Palabras»), Transcript («Transcripción»), Channel («Canal»), Views («Visualizaciones»), Found in («Encontrado en»), Published («Publicado»), Likes («Me gusta»), Video y Message («Mensaje»). Esta tabla es el dataset («conjunto de resultados»), la lista de resultados de la ejecución. Después de Download, el archivo está en tu carpeta Descargas.

La versión en un solo archivo está en la pestaña Storage («Almacenamiento») de la ejecución, en Key-value store («almacén de archivos»): mira «Descarga ALL_TRANSCRIPTS.md, la base de conocimiento en un archivo».

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

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 5
}

Qué datos recibes de cada video

Todos los campos de salida

Una fila por video. Los campos de la transcripción solo aparecen para los formatos elegidos y solo en las filas success.

Campo	Qué significa	Ejemplo
Resultado
status	Qué pasó con este video	success
message	El motivo cuando no hay transcripción, o una nota	""
charged	Si esta fila se cobró	true
input	El enlace del que salió esta fila	https://www.youtube.com/watch?v=arj7oStGLkU
scrapedAt	Cuándo se creó la fila (UTC)	2026-10-08T09:00:00+00:00
El video
videoId, url	El identificador de 11 caracteres y el enlace del video	arj7oStGLkU
title	Título	Inside the Mind of a Master Procrastinator | Tim Urban | TED
channelName, channelId	Canal e identificador del canal en YouTube	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	Verdadero para directos y sus grabaciones	false
Fecha, «me gusta» y tipo
publishedAt	Fecha y hora exactas de publicación	2016-04-06T09:59:35-07:00
likeCount	Número exacto de «me gusta» (vacío si el propietario los oculta)	2054977
category	Categoría de YouTube	People & Blogs
isShort	Verdadero para los Shorts	false
liveStartedAt, liveEndedAt	En directos: cuándo empezó y terminó la emisión
Dónde se encontró (videos de un canal o una lista)
source	El enlace del canal o de la lista que pegaste	https://www.youtube.com/@TED
sourceType	channel o playlist	channel
sourceTitle	Nombre del canal o de la lista	TED
positionInSource	Posición en la lista, empezando en 1	1
publishedText	La antigüedad tal como la muestra la lista de YouTube	2 hours ago
Idioma
language, languageName	Idioma de la transcripción que recibiste	en, English
isAutoGenerated	Verdadero cuando los subtítulos los escribió el reconocimiento de voz de YouTube	false
isTranslated, translatedFrom	Si es una traducción automática, y desde qué idioma	false
availableLanguages	Todos los idiomas de subtítulos del video (code, name, isAutoGenerated, isTranslatable)
La transcripción
text	Toda la transcripción como un párrafo	So in college, I was a government major, …
timestampedText	Una línea por subtítulo: [MM:SS] texto
segments	Líneas con start, duration, end (segundos) y text
srt, vtt	El contenido de un archivo de subtítulos
markdown	El video como documento Markdown	mira el ejemplo
files	Enlaces de descarga, cuando saveFiles está activado
data	Líneas de subtítulos como start, dur, text; solo cuando la entrada usó el campo único videoUrl
segmentCount, wordCount, charCount	Líneas, palabras y caracteres de la transcripción	315, 2277, 12671

Ejemplo de salida: una fila correcta y una fila no_captions

Un video pegado directamente, con los formatos text y markdown. Valores reales del 8 de octubre de 2026; los valores largos se acortan con "…".

{
    "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,
    "publishedAt": "2016-04-06T09:59:35-07:00",
    "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",
    "category": "People & Blogs",
    "likeCount": 2054977,
    "isShort": false,
    "liveStartedAt": null,
    "liveEndedAt": null,
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "markdown": "# Inside the Mind of a Master Procrastinator | Tim Urban | TED\n\n- Channel: TED\n- Published: 2016-04-06\n- URL: https://www.youtube.com/watch?v=arj7oStGLkU\n- Language: English\n\nSo in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}

Un video encontrado a través de un canal tiene cinco campos más. Estos vienen de una ejecución real de @TED:

{
    "source": "https://www.youtube.com/@TED",
    "sourceType": "channel",
    "sourceTitle": "TED",
    "positionInSource": 1,
    "publishedText": "2 hours ago"
}

Un video sin subtítulos encontrado en el mismo canal. 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": [],
    "wordCount": 0,
    "source": "https://www.youtube.com/@TED",
    "sourceType": "channel",
    "charged": false
}

Descarga ALL_TRANSCRIPTS.md, la base de conocimiento en un archivo

1. En la página de la ejecución, abre la pestaña Storage. Tiene tres partes: Dataset, Key-value store y Request queue («cola de peticiones»).
2. Abre Key-value store: una pequeña carpeta de archivos que pertenece a la ejecución.
   • Verás: una lista de nombres. Uno de ellos es ALL_TRANSCRIPTS.md.
3. Usa el control de descarga de su fila. Abre el archivo con cualquier editor de texto (Bloc de notas en Windows, TextEdit en un Mac): Markdown es texto plano con unas pocas marcas para títulos y listas.

Qué contiene: todos los videos que tienen transcripción, uno detrás de otro, separados por una línea. Cada video es como el valor markdown del ejemplo: un título, después las líneas Channel, Published, URL y Language, y después la transcripción en párrafos de alrededor de un minuto. Los videos sin transcripción no están en el archivo; están en la tabla con su motivo.

Una ejecución grande se divide en archivos de unos 8 MB, llamados ALL_TRANSCRIPTS_1.md, ALL_TRANSCRIPTS_2.md y así sucesivamente: descárgalos todos. La pestaña Log («Registro») de la ejecución nombra los archivos en una línea que empieza por "All transcripts in one place". Los archivos combinados de una ejecución guardan como máximo unos 60 millones de caracteres; a partir de ahí, las transcripciones están solo en la tabla. El archivo es gratis: no cambia el precio.

Después dáselo a tu herramienta de IA:

• NotebookLM: abre o crea un cuaderno y añade el archivo como fuente.
• ChatGPT: adjunta el archivo a un chat, o añádelo a los archivos de un proyecto o de un GPT personalizado.
• Claude: adjunta el archivo a un chat, o añádelo al conocimiento de un proyecto.
• Una base de conocimiento de empresa: importa el archivo. Si tu sistema prefiere un documento por video, activa 💾 Also save subtitle files I can download («Guardar también archivos de subtítulos que pueda descargar») y añade el formato Markdown: recibirás un archivo .md por video.

Descárgalo pronto: en el plan gratuito, un dataset sin nombre se borra a los 7 días.

Casos de uso

• Convierte un canal entero en una base de conocimiento para ChatGPT, Claude o NotebookLM en un solo archivo, y pregunta qué dijo el creador sobre cualquier tema, con video y fecha.
• Archiva tu propio canal como texto consultable para tu web, un curso o un libro.
• Estudia a un creador o a un competidor: de qué habla, cada cuánto publica, qué videos reciben más «me gusta».
• Mantén una base de conocimiento al día sin tocarla: una programación diaria añade solo los videos publicados desde la última ejecución.
• Convierte una lista de clases en apuntes de curso, en el idioma original o traducidos.
• Alimenta un sistema RAG con una fila por video, fechas exactas y bloques de texto de un minuto para citar con precisión.

Ejemplos de entrada

Todos los campos de entrada

Los campos van en el orden del formulario, con el nombre que se usa en JSON.

📺 Channels, playlists or videos (urls). Lo que quieres leer. Un enlace por línea; puedes mezclar tipos.

Pegas	Recibes
un canal: https://www.youtube.com/@TED o solo @TED	los videos del canal, primero los más nuevos
una pestaña de canal: https://www.youtube.com/@TED/shorts (también /videos, /streams)	solo ese tipo, de ese canal
una lista de reproducción: https://www.youtube.com/playlist?list=PL...	los videos de la lista, en su orden
un video: https://www.youtube.com/watch?v=arj7oStGLkU, un enlace youtu.be, un enlace de Shorts o el identificador de 11 caracteres	ese video

Un enlace de video que también nombra una lista (watch?v=...&list=...) cuenta como ese video suelto. Para recibir la lista entera, pega el enlace de la lista.

Campo del formulario (nombre en JSON)	Qué es	Ejemplo
🔢 Videos per channel or playlist (maxVideosPerSource)	El máximo de videos que se toman de cada canal o lista. El formulario empieza con 5 para que la primera prueba sea barata; si el campo falta (por ejemplo, en una llamada a la API), el valor es 50. Máximo 5000. Tres canales con 100 cada uno pueden dar hasta 300 filas.	100
🌐 Transcript language (languages)	«Idioma de la transcripción». Déjalo en "🎬 Original language of the video (recommended)" («Idioma original del video, recomendado») y cada video llega en el idioma en que se habla. O elige idiomas por orden de preferencia de la lista de 70; se usa el primero que tenga el video. También puedes escribir un código (pt-BR) o un nombre (Spanish, español). Se prefieren los subtítulos escritos por personas.	["es", "en"]
📄 Output formats (outputFormats)	«Formatos de salida»: segments, text, timestampedText, srt, vtt, markdown (un documento con título, canal, fecha y enlace). Elige los que quieras; el precio no cambia. Si no eliges, recibes segments y text.	["text"]
📚 Also give me everything as one Markdown file (combinedFile)	«Dame también todo en un archivo Markdown». Activado por defecto. Escribe ALL_TRANSCRIPTS.md en el almacén de archivos de la ejecución.	true
💾 Also save subtitle files I can download (saveFiles)	Desactivado por defecto. Un archivo por video para cada formato de texto elegido (.txt, .srt, .vtt, y .md si eliges Markdown), con enlaces de descarga en files.	true
📅 Only videos newer than (newerThan)	«Solo videos más recientes que». Vacío significa sin límite. Una fecha (2026-04-01) o una antigüedad (30 days, 6 months). Aproximado, mira más abajo.	"6 months"
Only new videos since the last run (onlyNewVideos)	«Solo videos nuevos desde la última ejecución». Para ejecuciones programadas: cada ejecución entrega solo los videos que no había entregado antes para los mismos canales y listas. Desactivado por defecto. Mira «Ejecútalo de forma programada y recibe solo los videos nuevos».	true
Memory name (stateKey)	«Nombre de la memoria». Opcional, solo con el campo anterior: el nombre de la lista de videos entregados.	"my-daily-news"
🎞️ Kinds of videos to take from a channel (contentTypes)	«Tipos de videos del canal»: videos normales (videos), Shorts (shorts), grabaciones de directos (streams). Al principio están marcados los tres. Se aplica a canales, no a listas.	["videos"]
🔁 Translate to (translateTo)	«Traducir a»: la traducción automática de YouTube a ese idioma, que se usa solo cuando el video no tiene subtítulos en él. YouTube no la ofrece para todos los videos; entonces recibes el idioma original y una nota en message.	"es"
If my language is missing, give me the original language (fallbackToAnyLanguage)	«Si falta mi idioma, dame el original». Activado por defecto. Desactívalo para omitir los videos que no tengan tus idiomas; los omitidos son gratis.	false
Caption type (captionType)	«Tipo de subtítulos»: "Any, human-made first" (any), "Human-made only" (manual) o "Auto-generated only" (auto). Los subtítulos automáticos a menudo no tienen puntuación.	"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. 0 conserva las líneas originales.	30
Include video details (includeMetadata)	«Incluir datos del video». Activado por defecto: canal, duración, visualizaciones, descripción, etiquetas y miniatura. Déjalo activado para el archivo de conocimiento: el nombre del canal de cada título sale de aquí.	true

Un canal entero, primero lo más nuevo

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 200,
    "outputFormats": ["text"]
}

Un lote: dos canales, 20 videos de cada uno

{
    "urls": ["https://www.youtube.com/@TED", "@anotherchannel"],
    "maxVideosPerSource": 20,
    "outputFormats": ["text"]
}

Una lista de reproducción, en español si existe, con un archivo Markdown por video

{
    "urls": ["https://www.youtube.com/playlist?list=PLxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"],
    "maxVideosPerSource": 500,
    "languages": ["es", "auto"],
    "outputFormats": ["markdown"],
    "saveFiles": true
}

Traducir un canal a un idioma

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 30,
    "translateTo": "es",
    "outputFormats": ["text", "markdown"]
}

Solo los Shorts de los últimos 30 días

{
    "urls": ["https://www.youtube.com/@TED"],
    "contentTypes": ["shorts"],
    "newerThan": "30 days",
    "maxVideosPerSource": 200
}

Solo videos nuevos, para una programación diaria

{
    "urls": ["https://www.youtube.com/@TED"],
    "maxVideosPerSource": 50,
    "onlyNewVideos": true,
    "stateKey": "ted-daily",
    "outputFormats": ["text", "markdown"]
}

Seis meses de un canal en un archivo de conocimiento, paso a paso

1. Prepara el formulario. 📺 Channels, playlists or videos: tu canal. 🔢 Videos per channel or playlist: 1000; es un techo, no un objetivo: la fecha decide cuántos videos se toman. 📄 Output formats: "Plain text (for reading and for AI)" («Texto plano, para leer y para IA»); el archivo Markdown se escribe de todos modos. 📅 Only videos newer than: 6 months. 🎞️ Kinds of videos to take from a channel: desmarca Shorts y grabaciones de directos si solo quieres videos normales.

   {
       "urls": ["https://www.youtube.com/@TED"],
       "maxVideosPerSource": 1000,
       "newerThan": "6 months",
       "contentTypes": ["videos"],
       "outputFormats": ["text"],
       "combinedFile": true
   }
   

2. Pon un techo al gasto. Despliega Run options («Opciones de ejecución») y escribe 5 en Maximum cost per run («Coste máximo por ejecución»): cinco dólares cubren unas 500 transcripciones. Deja Memory («Memoria») en 4 GB.

3. Haz clic en Start y observa. La línea de estado dice primero que se están enumerando los videos y después cuenta, por ejemplo "60/120 videos checked, 55 transcripts delivered". Las cifras son solo un ejemplo: las tuyas dependen del canal.

4. Revisa la tabla. Status te dice qué videos tienen transcripción; Published muestra la fecha exacta de cada video, así ves dónde terminan los seis meses.

5. Descarga el archivo de conocimiento desde Storage, Key-value store, y dáselo a tu herramienta de IA. Después pregunta con tus palabras: «¿Qué dijo este canal sobre precios en los últimos seis meses? Nombra los videos y sus fechas».

¿Hasta qué punto es exacto el filtro de fecha?

Se acerca, pero no al día. Cuando el Actor enumera un canal, YouTube muestra para cada video una antigüedad redondeada hacia abajo («hace 5 días», «hace 3 semanas», «hace 5 meses»), no una fecha. Un video marcado «hace 5 meses» puede tener cinco meses o casi seis. Por eso la regla es: un video se conserva siempre que pueda ser lo bastante nuevo. Nunca se deja fuera nada más nuevo que tu límite; unos pocos videos justo por encima del límite pueden colarse:

Antigüedad que muestra la lista de YouTube	Cuánto más antiguo que tu límite puede ser un video y aun así entrar
horas o días	menos de un día
semanas	hasta 6 días
meses	hasta un mes, aproximadamente
años	hasta un año

Un video que se cuela y tiene transcripción se entrega y se cobra como cualquier otro. Cada fila tiene la fecha exacta en publishedAt: ordena por ella en Excel y borra las filas que no quieras. Si escribes una antigüedad, un mes cuenta como 30 días y un año como 365, desde el día de la ejecución; 6 months significa 180 días atrás. Para un inicio preciso, elige una fecha del calendario. Un canal se enumera de lo más nuevo a lo más antiguo y la lectura se detiene poco después de pasar el límite; una lista de reproducción sigue el orden que eligió su propietario, así que se lee hasta el final y después se filtra.

Ejecútalo de forma programada y recibe solo los videos nuevos

Sigue un canal o una lista de reproducción y recibe cada video nuevo una sola vez, automáticamente.

Cómo funciona «Only new videos since the last run»

• Activa Only new videos since the last run (onlyNewVideos). Está desactivado por defecto y está pensado para ejecuciones programadas (las Schedules de Apify, «Programaciones»).
• Cada ejecución entrega entonces solo los videos que no había entregado antes para los mismos canales y listas. Los videos ya entregados se dejan fuera antes de pedir nada, así que ni se piden ni se cobran.
• La primera ejecución entrega todo lo que encuentra y lo recuerda.
• Los enlaces de videos que pegas directamente se entregan siempre, nunca se dejan fuera. Se recuerdan, así que un canal que los contenga más adelante no los vuelve a entregar.

Configúralo paso a paso

1. Rellena el formulario: tus canales o listas, 🔢 Videos per channel or playlist, tus formatos, y marca Only new videos since the last run. Opcional: escribe un Memory name como ted-daily.
2. Haz clic en Start una vez a mano. Esta primera ejecución entrega lo que encuentra y lo recuerda. Además deja el Actor listo para programarse: un Actor tiene que haberse ejecutado una vez antes de poder programarlo.
3. 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; aparece en Saved tasks («Tareas guardadas»).
4. Abre Schedules en el menú de la izquierda y haz clic en Create new («Crear nueva»).
5. En la tarjeta Schedule setup («Configuración de la programación») elige cada cuánto (una expresión cron como @daily, o el constructor visual) y tu zona horaria. Next runs («Próximas ejecuciones») muestra las fechas siguientes.
6. En el desplegable Add («Añadir») elige tu tarea.
7. Haz clic en Enable («Activar»). Las programaciones nuevas empiezan desactivadas.

Qué verás en las ejecuciones siguientes

• El registro y el mensaje final de la ejecución dicen cuántos videos se dejaron fuera, por ejemplo: "Skipped 37 videos already delivered in earlier runs (memory 'x')."
• Una ejecución sin nada nuevo termina con normalidad, sin filas: "No new videos since the last run: … Nothing was charged."

Nombre de la memoria: una lista o varias

• Vacío: la memoria se llama auto-… según tu lista de canales y listas de reproducción. Cualquier cambio en esa lista empieza una memoria nueva.
• Con un nombre: eliges tú el registro. El mismo nombre mantiene una sola lista de videos entregados aunque cambien los enlaces; un nombre distinto mantiene una lista aparte.
• Se conservan las letras, las cifras y -_.!'(); los demás caracteres se convierten en -.

Dónde se guarda la memoria y cómo empezar de cero

La memoria se guarda en tu propia cuenta de Apify: Storage > Key-value stores («almacenes de archivos»), en el almacén llamado youtube-transcripts-memory. Cada memoria es un registro que guarda los identificadores de los 20 000 videos entregados más recientes y la hora de su última actualización. Borra el registro, o el almacén entero, y la siguiente ejecución empieza de cero y vuelve a entregarlo todo.

Conviene saber

• Se recuerdan: los videos entregados como success o no_captions. Todo lo demás (blocked, error, age_restricted, un directo que sigue en marcha o no ha empezado) se vuelve a intentar en la siguiente ejecución.
• Mantén el número lo bastante alto. 🔢 Videos per channel or playlist cuenta los videos más nuevos que se miran en cada ejecución, antes de dejar fuera los conocidos. Ponlo por encima del número de videos que el canal publica entre dos ejecuciones.
• La memoria se guarda al final de la ejecución, también cuando la ejecución se detiene antes de su tiempo máximo o en el tope de gasto (entonces, solo con los videos que se procesaron). Tras un traslado de servidor, la ejecución continúa y guarda al final; nada se cuenta ni se cobra dos veces.
• Si la memoria no se puede leer, la ejecución anota un aviso y entrega todos los videos como una ejecución normal. Si no se puede guardar, los resultados se entregan igualmente, y la siguiente ejecución puede repetir algunos videos.
• Dos ejecuciones con la misma memoria al mismo tiempo pueden entregar las dos el mismo video nuevo. La memoria guarda los videos de ambas.

Envía los videos nuevos a Google Sheets o Slack

• n8n: añade el nodo Apify Trigger (Resource to Watch: Task, tu tarea; Event Type: Succeeded). Después un nodo Apify con Resource Dataset, Get Items y el defaultDatasetId de la ejecución como Dataset ID (sube Limit: empieza en 50). Después un nodo de Google Sheets que añada una fila por elemento (title, url, publishedAt, likeCount, text), o un nodo de Slack que publique title y url. Un n8n en tu propio servidor necesita una WEBHOOK_URL pública para que Apify pueda llegar a él.
• Make: empieza con Watch Actor Runs («Vigilar ejecuciones del Actor»; se dispara cuando termina una ejecución), después Get Dataset Items y después un módulo de Google Sheets (la guía de Apify usa "Bulk Add Rows") o de Slack.
• Cualquier otra herramienta: en la pestaña Integrations («Integraciones») de la tarea añade un webhook («aviso automático a otra aplicación») para el evento ACTOR.RUN.SUCCEEDED. Apify envía un POST a tu dirección; el identificador del dataset está en resource.defaultDatasetId. El receptor debe responder en menos de 2 minutos, y un webhook puede llegar dos veces.

Una ejecución sin videos nuevos termina igualmente como Succeeded, con un dataset vacío: ese día tu hoja simplemente no recibe filas nuevas.

Usa YouTube Channel Transcripts desde agentes de IA (MCP)

MCP es una forma de que un asistente de IA use herramientas externas. Esta dirección le da al asistente este Actor como herramienta:

https://mcp.apify.com?tools=nokia2k/youtube-channel-transcripts

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>. El asistente espera como máximo 45 segundos por una ejecución y después lee los resultados en un segundo paso, así que pide pocos videos cada vez; para un canal entero, ejecútalo aquí y sube ALL_TRANSCRIPTS.md. Cada ejecución usa tu crédito de Apify como cualquier otra.

Claude.ai y Claude Desktop

1. Abre la página de conectores (Settings > Connectors, o Customize > Connectors, según tu versión; «Configuración» o «Personalizar», y «Conectores»).
2. Elige Add custom connector («Añadir conector personalizado»).
3. Rellena Name («Nombre») y Remote MCP server URL («URL del servidor MCP remoto») con la dirección de arriba, haz clic en Continue («Continuar») y luego en Add («Añadir»).
4. Inicia sesión en Apify cuando el navegador te lo pida.
5. En un chat, haz clic en +, luego en Connectors, y activa el conector.

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-channel-transcripts": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "nokia2k/youtube-channel-transcripts"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}

Cursor

.cursor/mcp.json en tu proyecto, o ~/.cursor/mcp.json:

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

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:

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

Claude Code y ChatGPT

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

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

Ejemplos de peticiones

• «Consigue las transcripciones de los 5 videos más nuevos de @TED y resume cada uno en tres puntos.»
• «Lee los 10 últimos videos de este canal y dime qué temas salen más a menudo, con el video y la fecha de cada uno: [enlace del canal]»
• «Consigue las transcripciones de esta lista de reproducción y escribe una guía de estudio de una página: [enlace de la lista]»

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

Para casi todas necesitas un API token («token de API»): una clave secreta que permite a otro programa usar tu cuenta de Apify. Está en la consola, en Settings («Configuración») y luego API & Integrations («API e integraciones»). Trátalo como una contraseña. Abajo se escribe <YOUR_APIFY_TOKEN>. Un aviso para todas: un canal entero puede tardar más que el corto tiempo de espera que permiten algunas herramientas; donde importa, se dice en los pasos.

API: una llamada con curl

En las direcciones web el Actor se escribe nokia2k~youtube-channel-transcripts. Esta llamada inicia una ejecución y devuelve las filas; espera como máximo 300 segundos, y una ejecución más larga responde HTTP 408:

curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-channel-transcripts/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.youtube.com/@TED"], "maxVideosPerSource": 5, "outputFormats": ["text"]}'

Para canales enteros, inicia la ejecución con POST /v2/acts/nokia2k~youtube-channel-transcripts/runs, consulta GET /v2/actor-runs/<RUN_ID> hasta que el estado sea SUCCEEDED y lee GET /v2/datasets/<DATASET_ID>/items?format=json&clean=true. El archivo combinado es un registro del almacén de archivos de la ejecución, cuyo identificador viene en los mismos datos de la ejecución:

curl -L "https://api.apify.com/v2/key-value-stores/<STORE_ID>/records/ALL_TRANSCRIPTS.md" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -o ALL_TRANSCRIPTS.md

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-channel-transcripts").call(
    run_input={
        "urls": ["https://www.youtube.com/@TED"],
        "maxVideosPerSource": 200,
        "newerThan": "6 months",
        "outputFormats": ["text"],
    },
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["status"], item.get("publishedAt"), item.get("title"))

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-channel-transcripts').call(
    { urls: ['https://www.youtube.com/@TED'], maxVideosPerSource: 200, newerThan: '6 months' },
    { maxTotalChargeUsd: 5 },
);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((item) => item.status === 'success').length, 'transcripts');

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-channel-transcripts",
    run_input={
        "urls": ["https://www.youtube.com/@TED"],
        "maxVideosPerSource": 20,
        "outputFormats": ["text"],
        "combinedFile": False,
    },
    dataset_mapping_function=lambda row: Document(
        page_content=row.get("text") or "",
        metadata={
            "source": row.get("url"),
            "title": row.get("title"),
            "publishedAt": row.get("publishedAt"),
            "status": row.get("status"),
        },
    ),
)
docs = [d for d in loader.load() if d.metadata["status"] == "success"]

n8n

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

1. Instala el nodo de Apify. En n8n Cloud: abre el panel de nodos, busca Apify (en More from the community, «Más de la comunidad») e instálalo. En tu propio servidor: Settings > Community Nodes, Install, paquete @apify/n8n-nodes-apify.
2. Crea la credencial Apify API y pega tu token en API Key.
3. Añade el nodo Apify. Elige Resource («Recurso») Actor y Operation («Operación») Run an Actor and Get Dataset («Ejecutar un Actor y obtener los resultados»).
4. En Actor elige YouTube Channel Transcripts. En Input JSON pega, por ejemplo: {"urls": ["https://www.youtube.com/@TED"], "maxVideosPerSource": 20, "outputFormats": ["text"]}.
5. Pon Memory en 4096. El nodo envía 1024 si no lo cambias, y con eso los canales grandes van mucho más lentos. Opcional: Maximum Cost per Run (USD).
6. Ejecuta.
   • Verás: cada video como un elemento de n8n; conecta el nodo siguiente.
7. Para el archivo Markdown, usa la operación Run an Actor: devuelve los datos de la ejecución, con el identificador del dataset (defaultDatasetId) y el del almacén de archivos. Lee la tabla con Resource Dataset, Get Items (sube Limit: empieza en 50), y el archivo con Resource Key-Value Store, Get Key-Value Store Record, indicando ese almacén y el nombre ALL_TRANSCRIPTS.md.

Make

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

1. Añade el módulo Run an Actor («Ejecutar un Actor»). Rellena Connection («Conexión»), Actor e Input JSON, pon Memory en 4096 y Run synchronously («Ejecutar de forma síncrona») en Yes.
2. Añade Get Dataset Items («Obtener los resultados») y asigna en Dataset ID el defaultDatasetId del primer módulo. Sube Limit («Límite») para que lleguen todas las filas.
3. Añade tu destino, por ejemplo un módulo de Google Sheets.

Una ejecución síncrona en Make solo es segura hasta unos 2 minutos. Para un canal entero usa el otro esquema: inicia la ejecución desde la consola o una programación, y construye el escenario a partir del disparador Watch Actor Runs seguido de Get Dataset Items.

Zapier

Zapier espera solo 30 segundos por una ejecución síncrona; después el resultado se pierde. Unos pocos videos caben; un canal, no. Usa dos Zaps:

1. Zap A: tu disparador y después la acción Run Actor, configurada como asíncrona.
2. Zap B: el disparador Finished Actor Run («Ejecución del Actor terminada»), después Fetch Dataset Items («Traer los resultados») y después tu destino. Get Key-Value Store Record trae ALL_TRANSCRIPTS.md.

Google Sheets y Excel

1. Excel: en la pestaña Output haz clic en Export, elige Excel y haz clic en Download. En la ventana de exportación, Select fields («Elegir campos») te deja conservar solo algunas columnas, por ejemplo title, publishedAt, likeCount, viewCount, url, text.
2. Google Sheets a mano: exporta como CSV o Excel e importa ese archivo en Sheets.
3. Google Drive, automáticamente: 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»). Después de cada ejecución correcta, el archivo aparece en la carpeta Apify Uploads.

Una transcripción larga en una celda de hoja de cálculo se lee mal. Para leer, usa el archivo Markdown.

¿Cuánto cuesta conseguir todas las transcripciones de un canal de YouTube?

El precio es $9.99 por cada 1000 transcripciones en el momento de escribir esto. «Por cada 1000» es solo una forma de escribir un número pequeño: cada transcripción entregada cuesta $0.00999, alrededor de un centavo, y se cuenta una a una. Se suma la tarifa de inicio de Apify: $0.00005 por ejecución por cada GB de memoria, así que $0.0002 por una ejecución con los 4 GB por defecto. No se cobra nada más por una ejecución: ni uso de plataforma ni proxies. El precio que vale para tu plan es el de la pestaña Pricing («Precios») del Actor.

Una ejecución con	Transcripciones entregadas	Transcripciones	Inicio (4 GB)	Total
10 videos	10	$0.0999	$0.0002	$0.1001
1000 videos	1000	$9.99	$0.0002	$9.9902
10 000 videos	10 000	$99.90	$0.0002	$99.9002

Los videos sin transcripción se restan: 100 videos de los que 12 no tienen subtítulos cuestan 88 × $0.00999 = $0.88. Con Only new videos since the last run pagas solo los videos nuevos: 30 ejecuciones diarias que encuentran 60 videos nuevos en un mes cuestan 60 × $0.00999 + 30 × $0.0002 = $0.6054.

Lo que cubre el plan gratuito: $5 de crédito cada mes, sin tarjeta. Son unas 500 transcripciones al mes. El crédito que no usas no pasa al mes siguiente.

Nunca se cobra: los videos sin subtítulos; los privados, borrados, de pago y con restricción de edad; los videos que YouTube rechazó o que fallaron; las líneas que no son enlaces de YouTube; los canales o listas que no se pudieron enumerar; un video que aparece dos veces (se pide una sola vez); los videos que se dejan fuera porque una ejecución anterior ya los entregó; los formatos adicionales, el archivo Markdown, los archivos de subtítulos, la traducción, la fecha y los «me gusta».

Cómo poner un tope al gasto: Run options y luego Maximum cost per run. El Actor deja de tomar videos en esa cantidad, termina la ejecución con normalidad y te dice cuántos videos quedaron. Lo entregado se queda, y el archivo Markdown se escribe igualmente. En la API el límite es maxTotalChargeUsd; en n8n, Maximum Cost per Run (USD).

Errores y solución de problemas

Qué significa cada estado

Mira el status de la fila y después su message.

status	En palabras sencillas	Qué hacer
success	Se entregó la transcripción.	Nada. Es el único estado que se cobra.
no_captions	El video no tiene subtítulos de ningún tipo, o es un directo que sigue en marcha.	No hay nada que obtener: el Actor no escucha el sonido. Para un directo, vuelve a ejecutarlo unas horas después de que termine.
language_unavailable	El video tiene subtítulos, pero no en los idiomas ni del tipo que elegiste, y la alternativa está desactivada.	Mira availableLanguages. Activa la alternativa o cambia el idioma.
video_unavailable	El video se borró o nunca existió.	Revisa el enlace.
video_unplayable	Privado, de pago, bloqueado en la región o retirado por YouTube.	Lee 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.
invalid_input	La línea no es un enlace ni un identificador de YouTube.	Corrige la línea.
source_problem	No se pudo enumerar un canal o una lista. message dice por qué: un error al escribir el nombre, una lista privada, un Mix de YouTube, "Watch later" («Ver más tarde») o "Liked videos" («Videos que me gustan»), o ningún video desde tu fecha.	Corrige el enlace o amplía la fecha.

Problemas y soluciones

• «Menos videos de los que pedí.» El canal tiene menos videos públicos, el filtro de fecha o de tipo dejó fuera algunos, un video ya estaba en otra lista, se omitieron videos programados, la memoria dejó fuera videos entregados antes, o se llegó al tope de gasto.
• «Algunos videos son un poco más antiguos que mi fecha.» El filtro de fecha es aproximado; mira «¿Hasta qué punto es exacto el filtro de fecha?». Ordena por publishedAt para un corte exacto.
• «Las filas no siguen el orden del canal.» Se procesan muchos videos a la vez, así que las filas llegan a medida que terminan. Ordena la tabla por publishedAt o por positionInSource.
• «Mi ejecución programada no entregó nada.» Lee su mensaje final: "No new videos since the last run" significa que la memoria funcionó y no se cobró nada.
• «Mi ejecución programada volvió a entregarlo todo.» La lista de canales cambió sin un Memory name (empieza una memoria nueva), o se borró el registro de la memoria. Usa un Memory name fijo.
• «Mi herramienta de IA dice que el archivo es demasiado grande.» Ejecuta el canal por partes (por fecha, o lista por lista), o activa saveFiles con el formato Markdown para recibir un archivo por video.
• «n8n va lento o da una salida rara.» Pon Memory en 4096, y usa Run an Actor and Get Dataset, no Run an Actor, para las filas.
• «Make o Zapier perdieron el resultado.» Los canales enteros tardan más que sus límites síncronos. Usa Watch Actor Runs (Make) o dos Zaps.

Límites que conviene conocer

• No escucha el sonido. Un video sin ningún subtítulo da no_captions.
• No lee videos con restricción de edad, privados ni solo para miembros, tampoco tus propios videos privados.
• Sin «no me gusta», y sin comentarios ni número de suscriptores en este Actor.
• El filtro de fecha es aproximado, como se explica arriba.
• Como máximo 5000 videos por canal o lista en una ejecución.
• Algunas listas no se pueden leer: listas privadas, un Mix de YouTube, «Ver más tarde» y «Videos que me gustan».
• Los videos programados que aún no se han publicado se omiten.
• El archivo combinado tiene un techo de unos 60 millones de caracteres por ejecución. A partir de ahí, las transcripciones están solo en la tabla.

Preguntas frecuentes

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

Lo más frecuente es que no tenga subtítulos: música, clips sin voz, o un idioma que el reconocimiento de voz de YouTube no cubre. El status y el message de la fila dan el motivo exacto.

¿Me cobran cuando no hay transcripción?

No. Solo se cobran las filas con el estado success. El campo charged de cada fila también lo dice.

¿Qué significa «$9.99 por cada 1000» y cuánto costará mi canal?

Significa $0.00999 por transcripción entregada. Cuenta los videos que esperas y multiplica por un centavo: 300 videos son como máximo $3, más $0.0002 por ejecución.

¿Puedo obtener las transcripciones de los Shorts de un canal?

Sí. Los Shorts de un canal se incluyen salvo que los desmarques, y isShort los señala. Pega https://www.youtube.com/@nombre/shorts para recibir solo los Shorts.

¿Puedo obtener las transcripciones de los directos?

Las grabaciones de directos terminados funcionan cuando YouTube ha creado subtítulos para ellas, lo que puede tardar desde unas horas hasta un día después de la emisión. Un directo que sigue en marcha da no_captions, gratis.

¿Puedo mezclar canales, listas de reproducción y videos sueltos?

Sí, en el mismo campo, uno por línea. Un video que aparece en dos de ellos se pide una sola vez.

¿Qué idioma recibo y puede traducir?

Por defecto, el idioma que se habla en el video. Puedes fijar un orden de preferencia, y 🔁 Translate to pide la traducción automática de YouTube cuando el video la ofrece.

¿Transcribe el audio cuando no hay subtítulos?

No. Lee los subtítulos que 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. Se prueban dos identidades de aplicación y tres tipos de conexión antes de dar un video por blocked. En la prueba de 3629 videos no se bloqueó ninguno. Si alguna vez ocurre, la fila dice blocked, no cuesta nada y se puede volver a ejecutar.

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

La tabla está en la pestaña Output de la ejecución. El archivo Markdown está en Storage y luego Key-value store. Las ejecuciones anteriores están en Runs («Ejecuciones») en el menú de la izquierda. 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»).

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

Los campos de la transcripción solo aparecen para los formatos elegidos y solo en las filas success. Los cinco campos de «dónde se encontró» solo existen en los videos que vinieron de un canal o una lista. likeCount está vacío cuando el propietario ocult