# YouTube Video to Text (`nokia2k/youtube-video-to-text`) Actor

YouTube video to text in bulk: paste video links, a playlist or a channel and get each video's words as clean plain text for ChatGPT, Claude or notes. Any language, nothing to set up. No captions, no charge. $1.99 per 1,000 on the Free plan, from $0.99 on paid plans.

- **URL**: https://apify.com/nokia2k/youtube-video-to-text.md
- **Developed by:** [nokia2k](https://apify.com/nokia2k) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 transcripts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**YouTube video to text, in bulk: paste video links, a playlist or a channel and get the words of each video as clean plain text, ready for ChatGPT, Claude, notes or a spreadsheet.**

**$1.99 per 1,000 videos on Apify's Free plan, down to $0.99 on paid plans** (prices at the time of writing): a fifth of a cent or less each.

**Videos that fail or have no captions are never charged.**

🇪🇸 [Guía completa en español](#guia-completa-en-espanol)

### What does YouTube Video to Text do?

This Actor (Apify's word for a tool that runs on its servers) reads the captions YouTube keeps for each video, written by a person or generated automatically, and joins them into one paragraph. It does one thing: YouTube to text. No timestamps, no subtitle files, no translation, no video description. Nothing to set up: no YouTube key, no login, no proxy.

#### Why people pick it

- **The lowest price of this developer's YouTube tools:** $1.99 per 1,000 texts on the Free plan and $0.99 on Business, made for big lists.
- **Paste the whole list once.** 200 links, or thousands. Every common link form works, and a video pasted twice is read and charged once.
- **Whole playlists and channels too.** Paste a playlist link or a channel link (`@name`) and get the text of its videos, up to the number you set.
- **No language code to type.** Each video comes back in the language it is spoken in. Or pick from 70 languages, or type a code or a name.
- **A row for every link.** Each row has a `status` and a plain `message`. A video without captions is a free row, not a failed run.
- **You see what you paid for.** The `charged` field is `true` only on rows that carry text.
- **Ready for an AI chat.** Export title, link and text in one file, or tick **📚 Also give me everything as one Markdown file**, and upload it to ChatGPT or Claude.

#### Measured speed and reliability

Three videos took **2.8 seconds** from start to finish, measured on the Apify platform on 7–8 October 2026. Your numbers will differ a little.

The Actor reads up to 40 videos at the same time and asks for each video over one connection at a time. It does not race two connections for one video: that keeps it simple and cheap. If every second counts, use [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper).

Reliability, measured on 8 October 2026: 3,629 videos from 20 channels in two runs gave 3,447 texts, 171 videos without captions, 10 age-restricted videos, 1 video that 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) all got the right answer.

### Quick start: turn YouTube videos into text in 5 steps

You need a web browser. Nothing else.

1. **Make a free account.** Open `https://console.apify.com/sign-up`. Click **Continue with Google**. Or type your email and a password of 8 characters or more, click **Sign up**, and click the link in the email Apify sends you. No email? Sign in again and click **Resend verification email**.
   - *You see:* Apify Console, the control panel. The free plan costs $0, gives $5 of credit each month and asks for no card.
2. **Open this Actor.** Go to `https://apify.com/nokia2k/youtube-video-to-text` and click **Try for free**. If you land elsewhere, click **Apify Store** in the Console's left menu, search for "YouTube Video to Text" and click it.
   - *You see:* the **Input** tab, a short form. Its first box, **📺 YouTube videos, playlists or channels**, holds two example links.
3. **Paste your links** in place of the examples, one per line or a whole list at once. To get a link, open the video on YouTube and copy the address from the top of your browser.
4. **Click Start.**
   - *You see:* the Actor works. One job, from **Start** to the end, is called a **run**. After a few seconds it says **Succeeded**.
5. **Open the Output tab, click Export, choose a format and click Download.** Excel for a spreadsheet, or JSON, CSV, XML, HTML table, RSS, JSONL. **Preview** shows the file first.
   - *You see:* first a table with one row per video. The **Transcript** column holds the text; a **Status** of `success` means the text was delivered. The other columns are **Title**, **Language**, **Auto-generated**, **Duration (s)**, **Words**, **Channel**, **Video** and **Message**. After **Download**, the file is in your Downloads folder.

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

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

Tip: to export only the words, enter `title`, `url` and `text` under **Select fields** in the export window.

### What data do you get from each video?

Each entry of your list becomes one row. Apify calls the table that holds the rows of a run a **dataset**. On the run's **Output** tab, the **Overview** view shows title, status, language, words and the text; the **Languages** view shows which caption languages each video has.

#### Every output field

| Field | Meaning | Example |
| --- | --- | --- |
| **The text** | | |
| `text` | The whole transcript as one paragraph. Only on `success` rows. | `So in college, I was …` |
| `wordCount` | Words in the text. | `2277` |
| `charCount` | Characters in the text. Use it for languages written without spaces. | `12671` |
| **The video** | | |
| `videoId` | The 11-character ID. Empty when your entry was not a video. | `arj7oStGLkU` |
| `url` | The standard link to the video. | `https://www.youtube.com/watch?v=arj7oStGLkU` |
| `title` | The title. | Inside the Mind of a Master Procrastinator | Tim Urban | TED |
| `channelName` | The channel that published it. | `TED` |
| `durationSeconds` | Length in seconds. | `844` |
| **The language** | | |
| `language` | Code of the language you got. | `en` |
| `languageName` | Its name, as YouTube shows it. | `English` |
| `isAutoGenerated` | `true`: made by YouTube's speech recognition. `false`: written by a person. | `false` |
| `availableLanguages` | Every caption language the video has, each with `code`, `name`, `isAutoGenerated`, `isTranslatable`. | see below |
| **The result** | | |
| `status` | What happened. See [Errors and troubleshooting](#errors-and-troubleshooting). | `success` |
| `message` | A plain explanation when there is no text, or a note such as "you got another language". | empty |
| `input` | Your entry, as you pasted it. | `https://youtu.be/arj7oStGLkU` |
| `scrapedAt` | When the row was made, in UTC. | `2026-10-08T09:00:00+00:00` |
| `charged` | `true` when the row was charged. | `true` |
| **Only for videos from a playlist or channel** | | |
| `source` | The playlist or channel link you pasted. | `https://www.youtube.com/@TED` |
| `sourceType` | `playlist` or `channel`. | `channel` |
| `sourceTitle` | Name of the playlist or channel. | `TED` |
| `positionInSource` | Place of the video in the list, from 1. | `1` |
| `publishedText` | The age of the video as YouTube's list shows it. | `3 weeks ago` |

#### Sample output: one success row and one no_captions row

Real values of 8 October 2026. The text and the list of languages are cut short here.

```json
{
    "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",
    "durationSeconds": 844,
    "language": "en",
    "languageName": "English",
    "isAutoGenerated": false,
    "availableLanguages": [
        { "code": "en", "name": "English", "isAutoGenerated": false, "isTranslatable": true }
    ],
    "wordCount": 2277,
    "charCount": 12671,
    "input": "https://youtu.be/arj7oStGLkU",
    "scrapedAt": "2026-10-08T09:00:00+00:00",
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}
```

The same run with a video that has no captions. Its ID and title are placeholders; the other values are real:

```json
{
    "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,
    "charCount": 0,
    "charged": false
}
```

Rows arrive in the order they finish, not in the order of your list. Use `input` to match them.

### Use cases

- **Turn a list of lectures into study notes** you can search, print or summarize.
- **Feed ChatGPT or Claude the exact words of dozens of videos** in one upload, and ask for summaries, quotes or a comparison.
- **Build a text dataset from YouTube** for research, keyword analysis or training material, at the lowest price per video.
- **Write blog posts, newsletters and show notes** from interviews and talks without retyping a word.
- **Check what a video really says** before you quote it, cite it or share it.
- **Archive the spoken content of your own videos** as plain text for your website or a knowledge base.

### Ready-made examples: open one and press Start

These setups were tested before they were published, one page each. Press **Run example** to get your own copy, then swap in your own links.

- [Bulk YouTube video links to plain text for ChatGPT](https://apify.com/nokia2k/youtube-video-to-text/examples/bulk-youtube-video-links-to-plain-text-for-chatgpt)
- [Turn YouTube lectures into text for study notes](https://apify.com/nokia2k/youtube-video-to-text/examples/turn-youtube-lectures-into-text-for-study-notes)
- [YouTube podcast episode to text](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-podcast-episode-to-text)
- [YouTube video to text in Spanish](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-video-to-text-in-spanish)
- [YouTube videos to text, one row per video for a spreadsheet](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-videos-to-text-one-row-per-video-for-a-spreadsheet)

### Input examples

#### Every input field

The form has six fields. Only the first is needed. The last two sit under **⚙️ More options**.

| Field in the form (JSON name) | What it is | Change it when | Example |
| --- | --- | --- | --- |
| **📺 YouTube videos, playlists or channels** (`videoUrls`) | Your list of links, one per line, or a whole list pasted at once. A video link gives that video; a playlist link gives the videos of the playlist; a channel link (`https://www.youtube.com/@name` or just `@name`) gives the channel's newest videos. | Always | `https://youtu.be/jNQXAC9IVRw` |
| **🔢 Videos per channel or playlist** (`maxVideosPerSource`) | How many videos to take from each playlist or channel. Default 50, up to 5,000. Video links are not counted. | You paste a playlist or a channel | `10` |
| **🌐 Transcript language** (`languages`) | Set to **🎬 Original language of the video (recommended)**: each video comes back in the language it is spoken in. Or pick from the list of 70, several in order of preference: the first one the video has is used. You can also type a code (`pt-BR`) or a name (`Spanish`, `español`, `Deutsch`). | You need one specific language | `["es", "en"]`: Spanish if the video has it, otherwise English |
| **📚 Also give me everything as one Markdown file** (`combinedFile`) | Also writes all transcripts of the run into one file, `ALL_TRANSCRIPTS.md`, with a heading, the channel and the link for every video, in the run's **Storage > Key-value store** tab. Large runs are split into files of about 8 MB. Off by default; the price stays the same. | You want to upload everything to ChatGPT, Claude or NotebookLM in one go | `true` |
| **If my language is missing, give me the original language** (`fallbackToAnyLanguage`) | On by default: a video without your language still gives its text, in its original language, and `message` says which. Off: that video is skipped as `language_unavailable`, free. | A text in the wrong language is of no use to you | `false` |
| **Caption type** (`captionType`) | **Any, human-made first** (`any`, the default), **Human-made only** (`manual`) or **Auto-generated only** (`auto`). | You need punctuation and correct names: choose **Human-made only**. Fewer videos have such captions; the rest come back free as `language_unavailable`. | `"manual"` |

The language setting picks among the captions a video already has. It does not translate. Captions written by people are used before auto-generated ones, and a short code also finds its regional forms: `en` finds `en-GB` and `en-US`.

#### A list of videos, each in its own language

```json
{
    "videoUrls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://youtu.be/iG9CE55wbtY"
    ]
}
```

#### Spanish first, English second, skip videos that have neither

```json
{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "languages": ["es", "en"],
    "fallbackToAnyLanguage": false
}
```

#### Only captions written by people

```json
{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "captionType": "manual"
}
```

#### Which YouTube links are accepted?

A normal link (`https://www.youtube.com/watch?v=jNQXAC9IVRw`), a short link (`https://youtu.be/jNQXAC9IVRw`), Shorts, live, embed, mobile and YouTube Music links, and the 11-character video ID alone (`jNQXAC9IVRw`). Extra parts at the end of a link (`&t=42s`) do no harm, and a link wrapped in quotes or brackets is cleaned up. A playlist link (`https://www.youtube.com/playlist?list=...`) gives the videos of the playlist, and a channel link (`https://www.youtube.com/@name`, `/channel/UC...`, or just `@name`) gives the channel's newest videos, both up to **Videos per channel or playlist**. Each of those rows says where it came from in `source`, `sourceType`, `sourceTitle` and `positionInSource`. A playlist or channel that cannot be listed gives a free row with the status `source_problem`. Search terms are not taken: a line such as `how to learn spanish` gives a free `invalid_input` row that says so.

For timestamps, subtitle files, translation, search terms or date filters, see [Related YouTube tools](#related-youtube-tools).

### Run it every day or every week

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

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

To get the text sent somewhere after each run, use the task's **Integrations** tab: **Upload results to GDrive** puts a file in your Google Drive, and a webhook (event `ACTOR.RUN.SUCCEEDED`) tells n8n, Make or your own server that the run has finished.

A channel link gives the channel's newest videos on every run, including ones an earlier run already delivered. To follow a channel and get only its new videos, use [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper).

### Use YouTube Video to Text from AI agents (MCP)

**MCP** lets an AI assistant run a tool by itself: you ask in the chat, the assistant runs this Actor and reads the text. The address to add is:

```text
https://mcp.apify.com?tools=nokia2k/youtube-video-to-text
```

You sign in to Apify in your browser when asked (OAuth); no token is stored in the configuration. A header `Authorization: Bearer <YOUR_APIFY_TOKEN>` works too. Each run is paid from your Apify plan at the same price as a run you start yourself. The assistant waits up to 45 seconds for a run and then reads the rows.

#### Claude.ai and Claude Desktop

1. Open the Connectors page. Apify's guide says **Settings**, then **Connectors**; Claude's help page says **Customize**, then **Connectors**.
2. Choose **Add custom connector**.
3. Type a **Name**, paste the address into **Remote MCP server URL**, click **Continue**, then **Add**.
4. Sign in to Apify when the browser asks.
5. In a chat, click **+**, then **Connectors**, and switch it on.

A free Claude plan allows one custom connector. On Team and Enterprise plans, an Owner of the organization adds it.

#### Claude Desktop with a local server

`claude_desktop_config.json`, needs Node.js:

```json
{
  "mcpServers": {
    "youtube-video-to-text": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "nokia2k/youtube-video-to-text"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

#### Cursor

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

```json
{
  "mcpServers": {
    "youtube-video-to-text": {
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text"
    }
  }
}
```

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:

```json
{
  "servers": {
    "youtube-video-to-text": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text"
    }
  }
}
```

#### Claude Code and ChatGPT

```bash
claude mcp add --transport http youtube-video-to-text \
  "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text" \
  --header "Authorization: Bearer $APIFY_TOKEN"
```

**ChatGPT** needs Developer mode. Go to **Settings > Apps & Connectors > Create**. Fill **Name**, **Description** and **MCP Server URL**, set **Authentication** to OAuth, click **Create**. In a chat, click **+**, then **More**, and pick the connector.

#### Example prompts

- "Get the text of https://www.youtube.com/watch?v=arj7oStGLkU and summarize it in five lines."
- "Read these four lectures and make one study sheet with the ten most important terms: \[link 1] \[link 2] \[link 3] \[link 4]"
- "Get the text of this interview and find every sentence where the guest talks about money: \[link]"

#### The simple way: upload a file

1. Run the Actor with your links.
2. On the **Output** tab, click **Export**.
3. Under **Select fields**, enter `title`, `url` and `text`.
4. Choose JSON or CSV and click **Download**.
5. Upload the file to your chat and ask: "Summarize each video in five lines."

If your chat says the file is too big, run a shorter list. The `wordCount` field shows how long each text is.

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

#### Your API token

n8n, Make and code need your **API token**: a secret key that lets another program use your Apify account. Find it in the Console under **Settings**, then **API & Integrations**. Here it is written `<YOUR_APIFY_TOKEN>`. Never share it.

#### API: one call with curl

The Actor ID is `nokia2k/youtube-video-to-text`; in API addresses write it with a tilde.

```bash
curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-video-to-text/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw", "https://youtu.be/iG9CE55wbtY"]}'
```

This call waits at most 300 seconds; a longer run returns HTTP 408. Add `?format=csv&maxTotalChargeUsd=1` to the address to get a CSV file and cap the cost at one dollar. For long lists, start the run with `POST /v2/acts/nokia2k~youtube-video-to-text/runs`, poll `GET /v2/actor-runs/<RUN_ID>` until the status is `SUCCEEDED`, then read `GET /v2/datasets/<DATASET_ID>/items?clean=true` with the run's `defaultDatasetId`.

#### Python

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

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nokia2k/youtube-video-to-text").call(
    run_input={"videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"]},
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["status"] == "success":
        print(item["title"], item["wordCount"], item["text"][:300])
    else:
        print(item["input"], item["status"], item["message"])
```

#### JavaScript

`npm install apify-client`:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('nokia2k/youtube-video-to-text').call({
    videoUrls: ['https://www.youtube.com/watch?v=jNQXAC9IVRw'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.status, item.title, item.text ?? item.message);
}
```

Notes for your code: the run ends as `SUCCEEDED` even when some videos gave no text, so check `status` on each row. Rows are not in input order: match them with `input` or `videoId`. Default memory is 1,024 MB; the range is 256 to 4,096 MB.

#### LangChain

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

```python
from langchain_apify import ApifyWrapper
from langchain_core.documents import Document

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

#### n8n

1. In the nodes panel, search for **Apify** and install it. On n8n Cloud it is under **More from the community**, and only an owner or admin can install it. On your own server: **Settings > Community Nodes**, **Install**, type `@apify/n8n-nodes-apify`. It needs n8n 1.57.0 or newer.
2. Add the **Apify** node. As credential choose **Apify API** and paste your token into **API Key**.
3. Set **Resource** to **Actor** and **Operation** to **Run an Actor and Get Dataset**.
4. In **Actor**, choose `nokia2k/youtube-video-to-text`.
5. In **Input JSON**, paste `{ "videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"] }`. Then replace the link with an n8n expression that points to the link from your first node.
6. Optional: set **Maximum Cost per Run (USD)**.
7. Run the node.
   - *You see:* one n8n item per video, with the words in `text`. Check that `status` is `success` first.

A common slip: **Run an Actor** returns facts about the run, not the text. Use **Run an Actor and Get Dataset**.

#### Make

1. Add the Apify module **Run an Actor**. In **Connection**, sign in to Apify or paste your **API token**.
2. Choose this Actor in **Actor**. Set **Run synchronously** to **Yes**. Paste your input into **Input JSON**.
3. Add **Get Dataset Items**. In **Dataset ID**, map `defaultDatasetId` from the first module. If it is not shown, run the scenario once and look again. Raise **Limit** for many videos.
4. Add the place where the text should go, and map `title` and `text`.

For a run longer than about 2 minutes, start with **Watch Actor Runs** instead, then **Get Dataset Items**.

#### Zapier

**Run Actor** can wait for the result, but only 30 seconds. Then the run is stopped and the result is lost. So for more than a few videos, build two Zaps.

1. **Zap A:** any trigger, then Apify **Run Actor**. Connect with **Allow Access**. Paste your input and let it run asynchronously, which means "do not wait".
2. **Zap B:** the trigger **Finished Actor Run**, then **Fetch Dataset Items**, then the place where the text should go.

#### Excel, Google Sheets, Google Drive

- **Excel:** **Export**, choose Excel, **Download**.
- **Google Sheets:** export as CSV or Excel, then import that file in Google Sheets. For an automatic sheet, put the Google Sheets step of Make, Zapier or n8n after the Apify steps above.
- **Google Drive, automatically:** on the Actor's page in the Console, open the **Integrations** tab. Choose **Upload results to GDrive**, click **Connect with Google**, set **Filename** and **Format**, click **Save**. Each successful run then puts a file in the `Apify Uploads` folder of your Drive.

### How much does it cost to convert YouTube videos to text?

**$1.99 per 1,000 videos with text on the Free plan**, at the time of writing, and less on paid plans. The price that counts is the one on the **Pricing** tab.

Paid Apify plans pay less, at the time of writing:

| Your Apify plan | Price per 1,000 videos with text |
| --- | --- |
| Free | $1.99 |
| Starter | $1.69 |
| Scale | $1.39 |
| Business | $0.99 |

The examples below use the Free plan price.

"Per 1,000" only shows a small price in a readable way. You do not buy a pack. Each video with text is charged alone: $0.00199. This is called **pay per event**: you pay per result. Apify adds a tiny start fee: $0.00005 per run for each GB of memory; this Actor uses 1 GB by default. You pay nothing else: no platform usage, no proxy fees.

| One run with | Videos that give text | Texts | Run start | Total |
| --- | --- | --- | --- | --- |
| 10 videos | 10 | $0.0199 | $0.00005 | **$0.01995** |
| 1,000 videos | 1,000 | $1.99 | $0.00005 | **$1.99005** |
| 10,000 videos | 10,000 | $19.90 | $0.00005 | **$19.90005** |

Videos without text are subtracted: 100 videos of which 12 have no captions cost 88 × $0.00199 = $0.18.

**The free plan** gives $5 of credit each month, with no card. That is about 2,500 texts a month. Unused credit is not carried over. When the $5 is used up, you wait for the next month or move to a paid plan.

**Never charged:** videos without captions; private, deleted, paid or age-restricted videos; wrong links; search terms; playlists or channels that cannot be listed; the second copy of a link; videos YouTube refused; videos a run did not get to.

**To cap a run:** open **Run options** on the **Input** tab and type an amount in **Maximum cost per run**. `1` means one dollar, about 500 videos. The Actor stops at the cap and says so; what it already delivered stays. To see what a run cost, open the run: the cost is shown on its page.

### Errors and troubleshooting

#### What each status means

Every row has a `status`. Only `success` is charged.

| `status` | In plain words | What to do |
| --- | --- | --- |
| `success` | The text was delivered. | Nothing. |
| `no_captions` | The video has no captions. Or it is a live stream that is still running. | Read `message`. Live stream: run it again some hours after it ends. Otherwise there is no text to get. |
| `language_unavailable` | No captions in your language or caption type, and the fallback is off. | Look at `availableLanguages`. Pick one of those, or turn the fallback on. |
| `video_unavailable` | Deleted, or never existed. | Check the link. |
| `video_unplayable` | Private, paid, blocked in the region, or removed by YouTube. `message` has YouTube's reason. | It cannot be read. |
| `age_restricted` | YouTube shows it only to signed-in adults. | It cannot be read. |
| `blocked` | YouTube refused every connection that was tried. | Run it again later. |
| `error` | Something unexpected. `message` says what. | Run it again. If it stays, see [Support and updates](#support-and-updates). |
| `invalid_input` | Not a YouTube link or ID, for example a search term. Or the list was empty. | Copy the link again from YouTube. To start from a topic, use [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper). |
| `source_problem` | A playlist or channel whose videos could not be listed: it does not exist, is private or empty. `message` says which. | Check the link. Run it again if it should work. |

#### Problems and solutions

- **"The run succeeded but a row has no text."** Read its `status` and `message`. Most often the video has no captions.
- **"The text has no punctuation."** It comes from auto-generated captions: check `isAutoGenerated`. Choose **Human-made only** if you need punctuation.
- **"I got another language."** The video does not have yours and the fallback is on. `message` says which language you got.
- **"A field is empty."** A row without text has no `text` and no `language`. A deleted video has no title.
- **"Fewer rows than links."** A video pasted twice counts once. A run that reached your spending cap or its time limit stops early and says how many videos were left.
- **"My chat says the file is too big."** Export fewer videos at a time; `wordCount` shows the length of each text.
- **"n8n gives me facts about the run, not the text."** Use **Run an Actor and Get Dataset**.
- **"Zapier lost the result."** Its synchronous runs stop after 30 seconds. Use two Zaps.

#### What it does not do

| You need | Use this instead |
| --- | --- |
| Timestamps, subtitle files (SRT, VTT), translation, the video description | [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) |
| Videos found by typing a topic | [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) |
| Likes, comments, chapters, publish date | [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) |

Two limits are the same in every tool of the family: they read captions that exist on YouTube and do not listen to the audio, and they cannot read age-restricted, private or members-only videos.

### FAQ

#### Why did a YouTube video come back without text?

Look at its `status` and `message`. Most often the video has no captions. See [Errors and troubleshooting](#errors-and-troubleshooting).

#### Am I charged when there is no text?

No. Only `success` rows are charged. The `charged` field says `true` or `false` on every row.

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

On the Free plan, each video with text costs $0.00199 (less on paid plans, see the table above). Multiply by your number of videos: 250 videos cost about $0.50, plus $0.00005 per run.

#### Can I convert YouTube Shorts to text?

Yes, when the Short has captions.

#### Can I get the text of a YouTube live stream?

Yes, after the stream has ended and YouTube has prepared the recording. That takes some hours, up to a day for long streams. A running stream gives `no_captions`, free. Run it again later.

#### Can I paste a YouTube channel or a playlist?

Yes. A playlist link gives the text of its videos, and a channel link (`@name`) the text of the channel's newest videos, up to **Videos per channel or playlist** (50 by default). You pay only for videos that give text. To get only the videos that are new since the last run, or to filter by date, use [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper).

#### Which language do I get? Can it translate?

The language spoken in the video, unless you ask for another one the video has. The `language` field says which. In rare cases YouTube gives no hint about the language: then you get English if the video has it, and `message` says it was a guess. This Actor does not translate. [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) does.

#### Does it listen to the audio when there are no captions?

No. It reads captions that already exist. No captions, no text, no charge.

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

You set up nothing. Before a video is reported as `blocked` or `error`, two separate app identities and three kinds of connection are tried. If YouTube still refuses, the row says `blocked`, free. Run it again later.

#### My run shows no data. Where are my results?

Click **Runs** in the left menu, click your run, then **Output**. Results are not kept forever: on the free plan an unnamed dataset expires after 7 days, so download in time. To keep a dataset, open it and choose **Rename** in the **Actions** menu. A named dataset is never deleted automatically.

#### Why is a field empty? Why no punctuation?

A row without text has no `text` and no `language`. A deleted video has no title. Text without punctuation comes from auto-generated captions: check `isAutoGenerated`.

#### Can I choose videos by date or by topic?

Not here. This Actor reads the links you give it. [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) has a date filter and also finds videos from the words you type.

#### Why are there fewer rows than links?

A video pasted twice counts once. A run that reached your spending cap or its time limit stops early and says how many videos were left. Those are not charged.

#### How do I get the text into n8n, Make, Zapier or Google Sheets?

Follow the numbered steps in [Integrations](#integrations-n8n-make-zapier-python-javascript-and-langchain).

#### Can ChatGPT or Claude use it?

Yes. The simple way: upload an exported file to the chat. The connected way: add the Actor through MCP. Both are explained in [Use it from AI agents](#use-youtube-video-to-text-from-ai-agents-mcp).

#### Can I get timestamps, SRT or VTT?

Not here. Those are subtitle formats with the time of every line. [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) makes them.

#### Can I get comments, likes or the publish date?

Not here. [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) gives those.

#### How many videos fit in one run? How many runs at once?

The list has no fixed limit. Lists of thousands are fine. How many runs can go at once depends on your Apify plan, for example 32 on Starter, 128 on Scale and 256 on Business.

#### What happens if Apify moves my run or it reaches its time limit?

If Apify moves your run to another server, it goes on where it stopped and no video is charged twice. A run with a time limit stops taking new videos shortly before it, ends normally and says how many videos were left; those are not charged. Each video gets 30 seconds in total and each request 25 seconds, so nothing hangs.

#### Is it legal to convert YouTube videos to text? What about private videos and dislikes?

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 cannot be read. Dislikes are not available.

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

| Word | Plain meaning |
| --- | --- |
| Actor | A tool that runs on Apify's servers. |
| Apify Console | The web control panel where you run Actors. |
| Run | One job of an Actor, from **Start** to the end. |
| Input, Output | What you give the Actor, and what it gives back. |
| Dataset | The table that holds the rows of one run. |
| Status | The word in each row that says what happened, such as `success`. |
| Captions | The words YouTube can show under a video. Also called subtitles. |
| Transcript | All the captions of a video joined into one text. |
| Auto-generated captions | Captions made by YouTube's speech recognition. They can have mistakes. |
| Video ID | The 11 characters that name one video, such as `jNQXAC9IVRw`. |
| JSON, CSV | Two file formats. Programs read JSON. Spreadsheets open CSV. |
| API, API token | A way for programs to use Apify without clicking, and your secret key for it. |
| MCP | A way to let an AI assistant run a tool by itself. |
| Pay per event | You pay for each result, not for time or a subscription. |

#### Something went wrong. Where do I get help?

In the **Issues** tab. See [Support and updates](#support-and-updates).

### Related YouTube tools

Need more than plain text? The same developer makes two more YouTube Actors, each for a different job. Prices per 1,000 results on the Free plan at the time of writing; paid Apify plans pay less.

| Actor | Use it when you have | You get | Price |
| --- | --- | --- | --- |
| **YouTube Video to Text 📝 (you are here)** | A big list of video links, a playlist or a channel | Plain text only, the lowest price | $1.99 |
| [YouTube Transcript Scraper ⚡](https://apify.com/nokia2k/youtube-transcript-scraper) | Video links, and you need more than text | Timestamps, SRT, VTT, translation, video description, in about 3 s | $2.99 |
| [YouTube Scraper 🧰](https://apify.com/nokia2k/youtube-all-in-one-scraper) | Links, a channel, a playlist or a topic, and you need numbers | Transcript plus likes, comments, chapters, channel facts | $4.99 |

### Support and updates

Open an issue on the **Issues** tab of this Actor. Include the link to your run, the link of the video that went wrong, and what you expected.

Last updated: October 2026.

**Get your first text: paste one link and click Start.**

### 🇪🇸 Guía completa en español

**Convierte videos de YouTube en texto, en bloque: pega enlaces de videos, una lista de reproducción o un canal y recibe las palabras de cada video como texto plano y limpio, listo para ChatGPT, Claude, tus apuntes o una hoja de cálculo.**

**$1.99 por cada 1000 videos con el plan Free de Apify, y desde $0.99 con los planes de pago** (precios en el momento de escribir esto): una quinta parte de centavo o menos cada uno.

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

Este Actor (así llama Apify a una herramienta que funciona en sus servidores) lee los subtítulos que YouTube guarda de cada video, escritos por una persona o generados automáticamente, y los une en un solo párrafo. Hace una sola cosa: texto. Sin marcas de tiempo, sin archivos de subtítulos, sin traducción, sin la descripción del video. No hay nada que configurar: ni clave de YouTube, ni inicio de sesión, ni proxy.

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

- **El precio más bajo de las herramientas de YouTube de este desarrollador:** $1.99 por cada 1000 textos con el plan Free y $0.99 con Business, pensado para listas grandes.
- **Pegas la lista entera una vez.** 200 enlaces, o miles. Sirven todas las formas habituales de enlace, y un video pegado dos veces se lee y se cobra una sola vez.
- **También listas de reproducción y canales enteros.** Pega el enlace de una lista o de un canal (`@nombre`) y recibes el texto de sus videos, hasta el número que elijas.
- **No hay que escribir códigos de idioma.** Cada video llega en el idioma en que se habla. O elige entre 70 idiomas, o escribe un código o un nombre.
- **Una fila por cada enlace.** Cada fila tiene un `status` y un `message` en lenguaje claro. Un video sin subtítulos es una fila gratuita, no una ejecución fallida.
- **Ves lo que pagaste.** El campo `charged` vale `true` solo en las filas que traen texto.
- **Listo para un chat de IA.** Exporta título, enlace y texto en un archivo, o marca **📚 Also give me everything as one Markdown file**, y súbelo a ChatGPT o Claude.

#### Velocidad y fiabilidad medidas

Tres videos tardaron **2.8 segundos** de principio a fin, medido en la plataforma de Apify el 7 y 8 de octubre de 2026. Tus cifras variarán un poco.

El Actor lee hasta 40 videos a la vez y pide cada video por una sola conexión a la vez. No hace competir dos conexiones por un mismo video: así es sencillo y barato. Si cada segundo cuenta, usa [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper).

Fiabilidad, medida el 8 de octubre de 2026: 3629 videos de 20 canales en dos ejecuciones dieron 3447 textos, 171 videos sin subtítulos, 10 videos con restricción de edad, 1 video fallido por tiempo agotado (0.03 %) y 0 bloqueados por YouTube. 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 todos la respuesta correcta.

### Inicio rápido: convierte videos de YouTube en texto en 5 pasos

Solo necesitas un navegador web.

1. **Crea una cuenta gratuita.** Abre `https://console.apify.com/sign-up`. Haz clic en **Continue with Google** («Continuar con Google»). O escribe tu correo y una contraseña de 8 caracteres o más, haz clic en **Sign up** («Registrarse») y después en el enlace del correo que te envía Apify. ¿No llega? Inicia sesión otra vez y haz clic en **Resend verification email** («Reenviar el correo de verificación»).
   - *Verás:* Apify Console («Consola de Apify»), el panel de control. El plan gratuito cuesta $0, da $5 de crédito cada mes y no pide tarjeta.
2. **Abre este Actor.** Entra en `https://apify.com/nokia2k/youtube-video-to-text` y haz clic en **Try for free** («Probar gratis»). Si llegas a otra página, haz clic en **Apify Store** («tienda de Apify») en el menú de la izquierda, busca "YouTube Video to Text" y haz clic en él.
   - *Verás:* la pestaña **Input** («Entrada»), un formulario corto. Su primera casilla, **📺 YouTube videos, playlists or channels** («Videos, listas o canales de YouTube»), trae dos enlaces de ejemplo.
3. **Pega tus enlaces** en lugar de los ejemplos, uno por línea o una lista entera de una vez. Para conseguir un enlace, abre el video en YouTube y copia la dirección de la parte de arriba del navegador.
4. **Haz clic en Start** («Iniciar»).
   - *Verás:* el Actor trabaja. Cada trabajo, desde **Start** hasta el final, se llama **ejecución**. Unos segundos después dice **Succeeded** («completada»).
5. **Abre la pestaña Output** («Salida»), **haz clic en Export** («Exportar»), **elige un formato y haz clic en Download** («Descargar»). Excel para una hoja de cálculo, o JSON, CSV, XML, HTML table, RSS, JSONL. **Preview** («Vista previa») te enseña el archivo antes.
   - *Verás:* primero una tabla con una fila por video. La columna **Transcript** («Transcripción») trae el texto; un **Status** («Estado») `success` significa que se entregó el texto. Las otras columnas son **Title** («Título»), **Language** («Idioma»), **Auto-generated** («Automático»), **Duration (s)** («Duración, en segundos»), **Words** («Palabras»), **Channel** («Canal»), **Video** y **Message** («Mensaje»). Después de **Download**, el archivo está en tu carpeta Descargas.

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

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

Consejo: para exportar solo las palabras, escribe `title`, `url` y `text` en **Select fields** («Elegir campos») en la ventana de exportación.

### Qué datos recibes de cada video

Cada entrada de tu lista se convierte en una fila. Apify llama **dataset** («conjunto de resultados») a la tabla que guarda las filas de una ejecución.

#### Todos los campos de salida

| Campo | Qué significa | Ejemplo |
| --- | --- | --- |
| **El texto** | | |
| `text` | Toda la transcripción como un solo párrafo. Solo en las filas `success`. | `So in college, I was …` |
| `wordCount` | Palabras del texto. | `2277` |
| `charCount` | Caracteres del texto. Úsalo en idiomas que se escriben sin espacios. | `12671` |
| **El video** | | |
| `videoId` | El identificador de 11 caracteres. Vacío si tu entrada no era un video. | `arj7oStGLkU` |
| `url` | El enlace estándar del video. | `https://www.youtube.com/watch?v=arj7oStGLkU` |
| `title` | El título. | Inside the Mind of a Master Procrastinator | Tim Urban | TED |
| `channelName` | El canal que lo publicó. | `TED` |
| `durationSeconds` | Duración en segundos. | `844` |
| **El idioma** | | |
| `language` | Código del idioma que recibiste. | `en` |
| `languageName` | Su nombre, tal como lo muestra YouTube. | `English` |
| `isAutoGenerated` | `true`: lo hizo el reconocimiento de voz de YouTube. `false`: lo escribió una persona. | `false` |
| `availableLanguages` | Todos los idiomas de subtítulos del video, cada uno con `code`, `name`, `isAutoGenerated`, `isTranslatable`. | mira abajo |
| **El resultado** | | |
| `status` | Qué pasó. Mira «Errores y solución de problemas». | `success` |
| `message` | Una explicación sencilla cuando no hay texto, o una nota como «recibiste otro idioma». | vacío |
| `input` | Tu entrada, tal como la pegaste. | `https://youtu.be/arj7oStGLkU` |
| `scrapedAt` | Cuándo se creó la fila, en UTC. | `2026-10-08T09:00:00+00:00` |
| `charged` | `true` cuando la fila se cobró. | `true` |
| **Solo en videos de una lista o un canal** | | |
| `source` | El enlace de lista o de canal que pegaste. | `https://www.youtube.com/@TED` |
| `sourceType` | `playlist` o `channel`. | `channel` |
| `sourceTitle` | Nombre de la lista o del canal. | `TED` |
| `positionInSource` | Lugar del video en la lista, desde 1. | `1` |
| `publishedText` | La antigüedad del video tal como la muestra la lista de YouTube. | `3 weeks ago` |

#### Ejemplo de salida: una fila correcta y una fila no_captions

Valores reales del 8 de octubre de 2026. El texto y la lista de idiomas están recortados.

```json
{
    "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",
    "durationSeconds": 844,
    "language": "en",
    "languageName": "English",
    "isAutoGenerated": false,
    "availableLanguages": [
        { "code": "en", "name": "English", "isAutoGenerated": false, "isTranslatable": true }
    ],
    "wordCount": 2277,
    "charCount": 12671,
    "input": "https://youtu.be/arj7oStGLkU",
    "scrapedAt": "2026-10-08T09:00:00+00:00",
    "text": "So in college, I was a government major, which means I had to write a lot of papers. …",
    "charged": true
}
```

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

```json
{
    "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,
    "charCount": 0,
    "charged": false
}
```

Las filas llegan en el orden en que terminan, no en el de tu lista. Usa `input` para emparejarlas.

### Casos de uso

- **Convierte una lista de clases en apuntes** que puedes buscar, imprimir o resumir.
- **Dale a ChatGPT o Claude las palabras exactas de decenas de videos** en una sola subida, y pide resúmenes, citas o una comparación.
- **Crea un conjunto de textos a partir de YouTube** para investigación, análisis de palabras clave o material de formación, al precio más bajo por video.
- **Escribe artículos, boletines y notas de programa** a partir de entrevistas y charlas sin volver a teclear una palabra.
- **Comprueba lo que dice de verdad un video** antes de citarlo o compartirlo.
- **Archiva el contenido hablado de tus propios videos** como texto plano para tu web o una base de conocimiento.

### Ejemplos listos para usar: ábrelo y pulsa Start

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

- [Bulk YouTube video links to plain text for ChatGPT](https://apify.com/nokia2k/youtube-video-to-text/examples/bulk-youtube-video-links-to-plain-text-for-chatgpt)
- [Turn YouTube lectures into text for study notes](https://apify.com/nokia2k/youtube-video-to-text/examples/turn-youtube-lectures-into-text-for-study-notes)
- [YouTube podcast episode to text](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-podcast-episode-to-text)
- [YouTube video to text in Spanish](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-video-to-text-in-spanish)
- [YouTube videos to text, one row per video for a spreadsheet](https://apify.com/nokia2k/youtube-video-to-text/examples/youtube-videos-to-text-one-row-per-video-for-a-spreadsheet)

### Ejemplos de entrada

#### Todos los campos de entrada

El formulario tiene seis campos. Solo el primero es necesario. Los dos últimos están en **⚙️ More options** («Más opciones»).

| Campo del formulario (nombre en JSON) | Qué es | Cámbialo cuando | Ejemplo |
| --- | --- | --- | --- |
| **📺 YouTube videos, playlists or channels** (`videoUrls`) | «Videos, listas o canales de YouTube». Tu lista de enlaces, uno por línea, o una lista entera pegada de una vez. Un enlace de video da ese video; un enlace de lista de reproducción da los videos de la lista; un enlace de canal (`https://www.youtube.com/@nombre` o solo `@nombre`) da los videos más recientes del canal. | Siempre | `https://youtu.be/jNQXAC9IVRw` |
| **🔢 Videos per channel or playlist** (`maxVideosPerSource`) | «Videos por canal o lista». Cuántos videos tomar de cada lista o canal. Por defecto 50, hasta 5000. Los enlaces de video no cuentan. | Pegas una lista o un canal | `10` |
| **🌐 Transcript language** (`languages`) | «Idioma de la transcripción». Viene en **🎬 Original language of the video (recommended)** («Idioma original del video, recomendado»): cada video llega en el idioma en que se habla. O elige de la lista de 70, varios por orden de preferencia: se usa el primero que tenga el video. También puedes escribir un código (`pt-BR`) o un nombre (`Spanish`, `español`, `Deutsch`). | Necesitas un idioma concreto | `["es", "en"]`: español si el video lo tiene; si no, inglés |
| **📚 Also give me everything as one Markdown file** (`combinedFile`) | «Dame también todo en un archivo Markdown». Escribe además todas las transcripciones de la ejecución en un solo archivo, `ALL_TRANSCRIPTS.md`, con un título, el canal y el enlace de cada video, en la pestaña **Storage > Key-value store** de la ejecución. Las ejecuciones grandes se dividen en archivos de unos 8 MB. Desactivado por defecto; el precio no cambia. | Quieres subirlo todo de una vez a ChatGPT, Claude o NotebookLM | `true` |
| **If my language is missing, give me the original language** (`fallbackToAnyLanguage`) | «Si falta mi idioma, dame el original». Activado por defecto: un video sin tu idioma da igualmente su texto, en su idioma original, y `message` dice cuál. Desactivado: ese video se omite como `language_unavailable`, gratis. | Un texto en otro idioma no te sirve | `false` |
| **Caption type** (`captionType`) | «Tipo de subtítulos»: **Any, human-made first** («Cualquiera, primero los de personas»; `any`, el valor por defecto), **Human-made only** («Solo de personas»; `manual`) o **Auto-generated only** («Solo automáticos»; `auto`). | Necesitas puntuación y nombres correctos: elige **Human-made only**. Menos videos tienen esos subtítulos; los demás vuelven gratis como `language_unavailable`. | `"manual"` |

El ajuste de idioma elige entre los subtítulos que el video ya tiene. No traduce. Los subtítulos escritos por personas se usan antes que los automáticos, y un código corto encuentra también sus variantes regionales: `en` encuentra `en-GB` y `en-US`.

#### Una lista de videos, cada uno en su idioma

```json
{
    "videoUrls": [
        "https://www.youtube.com/watch?v=jNQXAC9IVRw",
        "https://youtu.be/iG9CE55wbtY"
    ]
}
```

#### Primero español, después inglés; omitir los videos que no tengan ninguno

```json
{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "languages": ["es", "en"],
    "fallbackToAnyLanguage": false
}
```

#### Solo subtítulos escritos por personas

```json
{
    "videoUrls": ["https://www.youtube.com/watch?v=arj7oStGLkU"],
    "captionType": "manual"
}
```

#### Qué enlaces de YouTube se aceptan

Un enlace normal (`https://www.youtube.com/watch?v=jNQXAC9IVRw`), un enlace corto (`https://youtu.be/jNQXAC9IVRw`), enlaces de Shorts, directos, embed, móviles y de YouTube Music, y el identificador de 11 caracteres a secas (`jNQXAC9IVRw`). Las partes extra al final de un enlace (`&t=42s`) no molestan, y un enlace entre comillas o paréntesis se limpia solo. Un enlace de lista de reproducción (`https://www.youtube.com/playlist?list=...`) da los videos de la lista, y un enlace de canal (`https://www.youtube.com/@nombre`, `/channel/UC...`, o solo `@nombre`) da los videos más recientes del canal, en ambos casos hasta **Videos per channel or playlist**. Cada una de esas filas dice de dónde viene en `source`, `sourceType`, `sourceTitle` y `positionInSource`. Una lista o un canal que no se puede leer da una fila gratuita con el estado `source_problem`. Las búsquedas no se aceptan: una línea como `cómo aprender inglés` da una fila gratuita `invalid_input` que lo explica.

Para marcas de tiempo, archivos de subtítulos, traducción, búsquedas o filtros de fecha, mira «Herramientas de YouTube relacionadas».

### Ejecútalo cada día o cada semana

Útil cuando hay que leer otra vez la misma lista, por ejemplo un conjunto fijo de videos para un informe semanal.

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

Para que el texto se envíe a algún sitio después de cada ejecución, usa la pestaña **Integrations** («Integraciones») de la tarea: **Upload results to GDrive** deja un archivo en tu Google Drive, y un webhook («aviso automático a otra aplicación», evento `ACTOR.RUN.SUCCEEDED`) avisa a n8n, a Make o a tu propio servidor de que la ejecución ha terminado.

Un enlace de canal da los videos más recientes del canal en cada ejecución, también los que ya entregó una ejecución anterior. Para seguir un canal y recibir solo sus videos nuevos, usa [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper).

### Usa YouTube Video to Text desde agentes de IA (MCP)

**MCP** permite que un asistente de IA ejecute una herramienta por sí mismo: tú preguntas en el chat, el asistente ejecuta este Actor y lee el texto. La dirección que hay que añadir es:

```text
https://mcp.apify.com?tools=nokia2k/youtube-video-to-text
```

Inicias sesión en Apify en tu navegador cuando te lo pida (OAuth); no se guarda ningún token en la configuración. También sirve una cabecera `Authorization: Bearer <YOUR_APIFY_TOKEN>`. Cada ejecución se paga con tu plan de Apify al mismo precio que una que inicies tú. El asistente espera hasta 45 segundos por una ejecución y después lee las filas.

#### Claude.ai y Claude Desktop

1. Abre la página de conectores. La guía de Apify dice **Settings** («Configuración») y luego **Connectors** («Conectores»); la ayuda de Claude dice **Customize** («Personalizar») y luego **Connectors**.
2. Elige **Add custom connector** («Añadir conector personalizado»).
3. Escribe un **Name** («Nombre»), pega la dirección en **Remote MCP server URL** («URL del servidor MCP remoto»), 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 actívalo.

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:

```json
{
  "mcpServers": {
    "youtube-video-to-text": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--tools", "nokia2k/youtube-video-to-text"],
      "env": {
        "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

#### Cursor

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

```json
{
  "mcpServers": {
    "youtube-video-to-text": {
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text"
    }
  }
}
```

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:

```json
{
  "servers": {
    "youtube-video-to-text": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text"
    }
  }
}
```

#### Claude Code y ChatGPT

```bash
claude mcp add --transport http youtube-video-to-text \
  "https://mcp.apify.com?tools=nokia2k/youtube-video-to-text" \
  --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**, pon **Authentication** («Autenticación») en OAuth y haz clic en **Create**. En un chat, haz clic en **+**, luego en **More** («Más»), y elige el conector.

#### Ejemplos de peticiones

- «Consigue el texto de https://www.youtube.com/watch?v=arj7oStGLkU y resúmelo en cinco líneas.»
- «Lee estas cuatro clases y haz una hoja de estudio con los diez términos más importantes: \[enlace 1] \[enlace 2] \[enlace 3] \[enlace 4]»
- «Consigue el texto de esta entrevista y encuentra todas las frases en las que el invitado habla de dinero: \[enlace]»

#### La forma sencilla: sube un archivo

1. Ejecuta el Actor con tus enlaces.
2. En la pestaña **Output**, haz clic en **Export**.
3. En **Select fields**, escribe `title`, `url` y `text`.
4. Elige JSON o CSV y haz clic en **Download**.
5. Sube el archivo a tu chat y pide: «Resume cada video en cinco líneas».

Si tu chat dice que el archivo es demasiado grande, ejecuta una lista más corta. El campo `wordCount` muestra la longitud de cada texto.

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

#### Tu token de API

n8n, Make y el código necesitan tu **API token** («token de API»): una clave secreta que permite a otro programa usar tu cuenta de Apify. Está en la consola, en **Settings** y luego **API & Integrations** («API e integraciones»). Aquí se escribe `<YOUR_APIFY_TOKEN>`. No lo compartas nunca.

#### API: una llamada con curl

El identificador del Actor es `nokia2k/youtube-video-to-text`; en las direcciones de la API se escribe con una tilde.

```bash
curl -X POST "https://api.apify.com/v2/acts/nokia2k~youtube-video-to-text/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw", "https://youtu.be/iG9CE55wbtY"]}'
```

Esta llamada espera como máximo 300 segundos; una ejecución más larga devuelve HTTP 408. Añade `?format=csv&maxTotalChargeUsd=1` a la dirección para recibir un archivo CSV y poner el tope de gasto en un dólar. Para listas largas, inicia la ejecución con `POST /v2/acts/nokia2k~youtube-video-to-text/runs`, consulta `GET /v2/actor-runs/<RUN_ID>` hasta que el estado sea `SUCCEEDED` y lee `GET /v2/datasets/<DATASET_ID>/items?clean=true` con el `defaultDatasetId` de la ejecución.

#### Python

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

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nokia2k/youtube-video-to-text").call(
    run_input={"videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"]},
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item["status"] == "success":
        print(item["title"], item["wordCount"], item["text"][:300])
    else:
        print(item["input"], item["status"], item["message"])
```

#### JavaScript

`npm install apify-client`:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('nokia2k/youtube-video-to-text').call({
    videoUrls: ['https://www.youtube.com/watch?v=jNQXAC9IVRw'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(item.status, item.title, item.text ?? item.message);
}
```

Notas para tu código: la ejecución termina como `SUCCEEDED` aunque algunos videos no den texto, así que revisa `status` en cada fila. Las filas no siguen el orden de la entrada: emparéjalas con `input` o `videoId`. La memoria por defecto es de 1024 MB; el rango va de 256 a 4096 MB.

#### LangChain

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

```python
from langchain_apify import ApifyWrapper
from langchain_core.documents import Document

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

#### n8n

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

1. En el panel de nodos, busca **Apify** e instálalo. En n8n Cloud está en **More from the community** («Más de la comunidad»), y solo un propietario o administrador puede instalarlo. En tu propio servidor: **Settings > Community Nodes**, **Install**, escribe `@apify/n8n-nodes-apify`. Necesita n8n 1.57.0 o posterior.
2. Añade el nodo **Apify**. Como credencial elige **Apify API** y pega tu token en **API Key**.
3. Pon **Resource** («Recurso») en **Actor** y **Operation** («Operación») en **Run an Actor and Get Dataset** («Ejecutar un Actor y obtener los resultados»).
4. En **Actor**, elige `nokia2k/youtube-video-to-text`.
5. En **Input JSON**, pega `{ "videoUrls": ["https://www.youtube.com/watch?v=jNQXAC9IVRw"] }`. Después sustituye el enlace por una expresión de n8n que apunte al enlace de tu primer nodo.
6. Opcional: rellena **Maximum Cost per Run (USD)** («Coste máximo por ejecución»).
7. Ejecuta el nodo.
   - *Verás:* un elemento de n8n por video, con las palabras en `text`. Comprueba primero que `status` sea `success`.

Un despiste habitual: **Run an Actor** devuelve datos sobre la ejecución, no el texto. Usa **Run an Actor and Get Dataset**.

#### Make

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

1. Añade el módulo de Apify **Run an Actor** («Ejecutar un Actor»). En **Connection** («Conexión»), inicia sesión en Apify o pega tu **API token**.
2. Elige este Actor en **Actor**. Pon **Run synchronously** («Ejecutar de forma síncrona») en **Yes**. Pega tu entrada en **Input JSON**.
3. Añade **Get Dataset Items** («Obtener los resultados»). En **Dataset ID**, asigna el `defaultDatasetId` del primer módulo. Si no aparece, ejecuta el escenario una vez y vuelve a mirar. Sube **Limit** («Límite») si son muchos videos.
4. Añade el lugar donde debe ir el texto y asigna `title` y `text`.

Para una ejecución de más de unos 2 minutos, empieza mejor con **Watch Actor Runs** («Vigilar ejecuciones del Actor») y sigue con **Get Dataset Items**.

#### Zapier

**Run Actor** puede esperar el resultado, pero solo 30 segundos. Después la ejecución se detiene y el resultado se pierde. Así que, para más de unos pocos videos, crea dos Zaps.

1. **Zap A:** cualquier disparador y después **Run Actor** de Apify. Conecta con **Allow Access** («Permitir acceso»). Pega tu entrada y deja que se ejecute de forma asíncrona, es decir, «sin esperar».
2. **Zap B:** el disparador **Finished Actor Run** («Ejecución del Actor terminada»), después **Fetch Dataset Items** («Traer los resultados») y después el lugar donde debe ir el texto.

#### Excel, Google Sheets, Google Drive

- **Excel:** **Export**, elige Excel, **Download**.
- **Google Sheets:** exporta como CSV o Excel e importa ese archivo en Google Sheets. Para una hoja automática, pon el paso de Google Sheets de Make, Zapier o n8n después de los pasos de Apify de arriba.
- **Google Drive, automáticamente:** en la página del Actor en la consola, abre la pestaña **Integrations**. 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»). Cada ejecución correcta deja entonces un archivo en la carpeta `Apify Uploads` de tu Drive.

### ¿Cuánto cuesta convertir videos de YouTube en texto?

**$1.99 por cada 1000 videos con texto con el plan Free**, en el momento de escribir esto, y menos con los planes de pago. El precio que vale es el de la pestaña **Pricing** («Precios»).

Los planes de pago de Apify pagan menos, en el momento de escribir esto:

| Tu plan de Apify | Precio por cada 1000 videos con texto |
| --- | --- |
| Free | $1.99 |
| Starter | $1.69 |
| Scale | $1.39 |
| Business | $0.99 |

Los ejemplos de abajo usan el precio del plan Free.

«Por cada 1000» solo muestra un precio pequeño de forma legible. No compras un paquete. Cada video con texto se cobra por separado: $0.00199. Esto se llama **pago por evento**: pagas por resultado. Apify añade una pequeña tarifa de inicio: $0.00005 por ejecución por cada GB de memoria; este Actor usa 1 GB por defecto. No pagas nada más: ni uso de plataforma ni proxies.

| Una ejecución con | Videos que dan texto | Textos | Inicio | Total |
| --- | --- | --- | --- | --- |
| 10 videos | 10 | $0.0199 | $0.00005 | **$0.01995** |
| 1000 videos | 1000 | $1.99 | $0.00005 | **$1.99005** |
| 10 000 videos | 10 000 | $19.90 | $0.00005 | **$19.90005** |

Los videos sin texto se restan: 100 videos de los que 12 no tienen subtítulos cuestan 88 × $0.00199 = $0.18.

**El plan gratuito** da $5 de crédito cada mes, sin tarjeta. Son unos 2500 textos al mes. El crédito que no usas no pasa al mes siguiente. Cuando se acaban los $5, esperas al mes siguiente o pasas a un plan de pago.

**Nunca se cobra:** los videos sin subtítulos; los privados, borrados, de pago o con restricción de edad; los enlaces erróneos; las búsquedas; las listas o canales que no se pueden leer; la segunda copia de un enlace; los videos que YouTube rechazó; los videos a los que la ejecución no llegó.

**Para poner un tope:** abre **Run options** («Opciones de ejecución») en la pestaña **Input** y escribe una cantidad en **Maximum cost per run** («Coste máximo por ejecución»). `1` significa un dólar, unos 500 videos. El Actor se detiene en el tope y lo dice; lo que ya entregó se queda. Para ver cuánto costó una ejecución, ábrela: el importe aparece en su página.

### Errores y solución de problemas

#### Qué significa cada estado

Cada fila tiene un `status`. Solo se cobra `success`.

| `status` | En palabras sencillas | Qué hacer |
| --- | --- | --- |
| `success` | Se entregó el texto. | Nada. |
| `no_captions` | El video no tiene subtítulos. O es un directo que sigue en marcha. | Lee `message`. Si es un directo, vuelve a ejecutarlo unas horas después de que termine. Si no, no hay texto que obtener. |
| `language_unavailable` | No hay subtítulos en tu idioma o tu tipo de subtítulos, y la alternativa está desactivada. | Mira `availableLanguages`. Elige uno de esos, o activa la alternativa. |
| `video_unavailable` | Borrado, o nunca existió. | Revisa el enlace. |
| `video_unplayable` | Privado, de pago, bloqueado en la región o retirado por YouTube. `message` trae el motivo de YouTube. | No se puede leer. |
| `age_restricted` | YouTube solo lo muestra a adultos con sesión iniciada. | No se puede leer. |
| `blocked` | YouTube rechazó todas las conexiones que se probaron. | Vuelve a ejecutarlo más tarde. |
| `error` | Algo inesperado. `message` dice qué. | Vuelve a ejecutarlo. Si sigue, mira «Soporte y actualizaciones». |
| `invalid_input` | No es un enlace ni un identificador de YouTube, por ejemplo una búsqueda. O la lista estaba vacía. | Copia otra vez el enlace desde YouTube. Para partir de un tema, usa [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper). |
| `source_problem` | Una lista o un canal cuyos videos no se pudieron leer: no existe, es privado o está vacío. `message` dice cuál. | Revisa el enlace. Vuelve a ejecutarlo si debería funcionar. |

#### Problemas y soluciones

- **«La ejecución terminó bien, pero una fila no tiene texto.»** Lee su `status` y su `message`. Lo más frecuente es que el video no tenga subtítulos.
- **«El texto no tiene puntuación.»** Viene de subtítulos automáticos: mira `isAutoGenerated`. Elige **Human-made only** si necesitas puntuación.
- **«Recibí otro idioma.»** El video no tiene el tuyo y la alternativa está activada. `message` dice qué idioma recibiste.
- **«Un campo está vacío.»** Una fila sin texto no tiene `text` ni `language`. Un video borrado no tiene título.
- **«Hay menos filas que enlaces.»** Un video pegado dos veces cuenta una vez. Una ejecución que llegó a tu tope de gasto o a su tiempo máximo se detiene antes y dice cuántos videos quedaron.
- **«Mi chat dice que el archivo es demasiado grande.»** Exporta menos videos cada vez; `wordCount` muestra la longitud de cada texto.
- **«n8n me da datos de la ejecución, no el texto.»** Usa **Run an Actor and Get Dataset**.
- **«Zapier perdió el resultado.»** Sus ejecuciones síncronas se cortan a los 30 segundos. Usa dos Zaps.

#### Lo que no hace

| Necesitas | Usa esto |
| --- | --- |
| Marcas de tiempo, archivos de subtítulos (SRT, VTT), traducción, la descripción del video | [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) |
| Videos encontrados escribiendo un tema | [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) |
| «Me gusta», comentarios, capítulos, fecha de publicación | [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) |

Dos límites son iguales en todas las herramientas de la familia: leen los subtítulos que existen en YouTube y no escuchan el audio, y no pueden leer videos con restricción de edad, privados ni solo para miembros.

### Preguntas frecuentes

#### ¿Por qué un video de YouTube volvió sin texto?

Mira su `status` y su `message`. Lo más frecuente es que el video no tenga subtítulos. Mira «Errores y solución de problemas».

#### ¿Me cobran cuando no hay texto?

No. Solo se cobran las filas `success`. El campo `charged` dice `true` o `false` en cada fila.

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

En el plan Free, cada video con texto cuesta $0.00199 (menos en los planes de pago, mira la tabla de arriba). Multiplica por tu número de videos: 250 videos cuestan unos $0.50, más $0.00005 por ejecución.

#### ¿Puedo convertir Shorts de YouTube en texto?

Sí, cuando el Short tiene subtítulos.

#### ¿Puedo obtener el texto de un directo de YouTube?

Sí, cuando el directo ha terminado y YouTube ha preparado la grabación. Eso tarda unas horas, hasta un día en directos largos. Un directo en marcha da `no_captions`, gratis. Vuelve a ejecutarlo más tarde.

#### ¿Puedo pegar un canal o una lista de reproducción de YouTube?

Sí. Un enlace de lista de reproducción da el texto de sus videos, y un enlace de canal (`@nombre`) el de los videos más recientes del canal, hasta **Videos per channel or playlist** (50 por defecto). Solo pagas los videos que dan texto. Para recibir solo los videos nuevos desde la última ejecución, o filtrar por fecha, usa [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper).

#### ¿Qué idioma recibo? ¿Puede traducir?

El idioma que se habla en el video, salvo que pidas otro que el video tenga. El campo `language` dice cuál. En casos raros, YouTube no da ninguna pista sobre el idioma: entonces recibes inglés si el video lo tiene, y `message` dice que fue una suposición. Este Actor no traduce. [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) sí lo hace.

#### ¿Escucha el audio cuando no hay subtítulos?

No. Lee los subtítulos que ya existen. Sin subtítulos no hay texto ni cobro.

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

No configuras nada. Antes de dar un video por `blocked` o `error`, se prueban dos identidades de aplicación distintas y tres tipos de conexión. Si YouTube aun así lo rechaza, la fila dice `blocked`, gratis. Vuelve a ejecutarlo más tarde.

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

Haz clic en **Runs** («Ejecuciones») en el menú de la izquierda, luego en tu ejecución y después en **Output**. Los resultados no se guardan para siempre: en el plan gratuito, un dataset sin nombre caduca a los 7 días, así que descárgalo a tiempo. Para conservar un dataset, ábrelo y elige **Rename** («Cambiar nombre») en el menú **Actions** («Acciones»). Un dataset con nombre nunca se borra automáticamente.

#### ¿Por qué un campo está vacío? ¿Por qué no hay puntuación?

Una fila sin texto no tiene `text` ni `language`. Un video borrado no tiene título. El texto sin puntuación viene de subtítulos automáticos: mira `isAutoGenerated`.

#### ¿Puedo elegir videos por fecha o por tema?

Aquí no. Este Actor lee los enlaces que le das. [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) tiene un filtro de fecha y también encuentra videos a partir de las palabras que escribes.

#### ¿Por qué hay menos filas que enlaces?

Un video pegado dos veces cuenta una vez. Una ejecución que llegó a tu tope de gasto o a su tiempo máximo se detiene antes y dice cuántos videos quedaron. Esos no se cobran.

#### ¿Cómo llevo el texto a n8n, Make, Zapier o Google Sheets?

Sigue los pasos numerados de «Integraciones».

#### ¿Pueden usarlo ChatGPT o Claude?

Sí. La forma sencilla: sube al chat un archivo exportado. La forma conectada: añade el Actor mediante MCP. Las dos se explican en «Usa YouTube Video to Text desde agentes de IA».

#### ¿Puedo obtener marcas de tiempo, SRT o VTT?

Aquí no. Son formatos de subtítulos con la hora de cada línea. [YouTube Transcript Scraper](https://apify.com/nokia2k/youtube-transcript-scraper) los genera.

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

Aquí no. [YouTube Scraper](https://apify.com/nokia2k/youtube-all-in-one-scraper) los da.

#### ¿Cuántos videos caben en una ejecución? ¿Cuántas ejecuciones a la vez?

La lista no tiene un límite fijo. Listas de miles van bien. Cuántas ejecuciones pueden ir a la vez depende de tu plan de Apify, por ejemplo 32 en Starter, 128 en Scale y 256 en Business.

#### ¿Qué pasa si Apify traslada mi ejecución o llega a su tiempo máximo?

Si Apify traslada tu ejecución a otro servidor, continúa donde se quedó y ningún video se cobra dos veces. Una ejecución con tiempo máximo deja de tomar videos nuevos poco antes de él, termina con normalidad y dice cuántos videos quedaron; esos no se cobran. Cada video tiene 30 segundos en total y cada petición 25, así que nada se queda colgado.

#### ¿Es legal convertir videos de YouTube en texto? ¿Y los videos privados y los «no me gusta»?

El Actor lee lo que YouTube muestra públicamente a cualquier visitante. Lo que hagas con los textos es responsabilidad tuya. Respeta los derechos de autor y las condiciones de YouTube. Los videos privados no se pueden leer. Los «no me gusta» no están disponibles.

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

| Palabra | Significado sencillo |
| --- | --- |
| Actor | Una herramienta que funciona en los servidores de Apify. |
| Apify Console | El panel de control web donde ejecutas Actors. |
| Ejecución (run) | Un trabajo de un Actor, desde **Start** hasta el final. |
| Input, Output | Lo que le das al Actor y lo que te devuelve. |
| Dataset | La tabla con las filas de una ejecución. |
| Status | La palabra de cada fila que dice qué pasó, como `success`. |
| Subtítulos | Las palabras que YouTube puede mostrar bajo un video. |
| Transcripción | Todos los subtítulos de un video unidos en un texto. |
| Subtítulos automáticos | Subtítulos hechos por el reconocimiento de voz de YouTube. Pueden tener errores. |
| Identificador del video | Los 11 caracteres que nombran un video, como `jNQXAC9IVRw`. |
| JSON, CSV | Dos formatos de archivo. Los programas leen JSON. Las hojas de cálculo abren CSV. |
| API, token de API | Una forma de que los programas usen Apify sin hacer clic, y tu clave secreta para ello. |
| MCP | Una forma de dejar que un asistente de IA ejecute una herramienta por sí mismo. |
| Pago por evento | Pagas por cada resultado, no por tiempo ni con una suscripción. |

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

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

### Herramientas de YouTube relacionadas

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

| Actor | Úsalo cuando tienes | Recibes | Precio |
| --- | --- | --- | --- |
| **YouTube Video to Text 📝 (estás aquí)** | Una lista grande de enlaces de videos, una lista de reproducción o un canal | Solo texto plano, el precio más bajo | $1.99 |
| [YouTube Transcript Scraper ⚡](https://apify.com/nokia2k/youtube-transcript-scraper) | Enlaces de videos, y necesitas más que texto | Marcas de tiempo, SRT, VTT, traducción y descripción del video, en unos 3 s | $2.99 |
| [YouTube Scraper 🧰](https://apify.com/nokia2k/youtube-all-in-one-scraper) | Enlaces, un canal, una lista o un tema, y necesitas cifras | Transcripción más «me gusta», comentarios, capítulos y datos del canal | $4.99 |

### Soporte y actualizaciones

Abre una incidencia en la pestaña **Issues** de este Actor. Incluye el enlace de tu ejecución, el enlace del video que falló y lo que esperabas.

Última actualización: octubre de 2026.

**Consigue tu primer texto: pega un enlace y haz clic en Start.**

# Actor input Schema

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

Paste YouTube links, one per line, or a whole list at once. A <b>video</b> link (regular, youtu.be, Shorts, live, embed or mobile) or an 11-character video ID gives you that video. A <b>playlist</b> link gives you the videos of the playlist, and a <b>channel</b> link (<code>https://www.youtube.com/@name</code>, or just <code>@name</code>) the channel's newest videos, up to the number set below. Search terms are not taken here. Duplicates are fetched once.

## `maxVideosPerSource` (type: `integer`):

How many videos to take from each channel or playlist. Start with a small number to see what you get, then raise it. You only pay for transcripts that are delivered.

## `languages` (type: `array`):

Leave it on <b>Original language</b> to get each video in the language it is spoken in: you do not need to know the language in advance. Or pick one or more languages in order of preference, and the first one the video has is used. You can also type any language code (<code>pt-BR</code>, <code>es-419</code>) or a language name (<code>Spanish</code>, <code>español</code>, <code>German</code>). Captions written by people are preferred over auto-generated ones. Every row tells you which language was returned and which other languages the video has.

## `combinedFile` (type: `boolean`):

Saves all transcripts of the run into one file, <code>ALL_TRANSCRIPTS.md</code>, with a heading, the channel, the date and the link for every video. Upload it to ChatGPT, Claude, NotebookLM or your knowledge base in one go. You find it in the run's <b>Storage > Key-value store</b> tab. Large runs are split into files of about 8 MB. The price stays the same.

## `fallbackToAnyLanguage` (type: `boolean`):

When on, a video without captions in the languages you picked still returns its transcript in its original language, and the <code>language</code> and <code>message</code> fields tell you which one. Turn it off to skip those videos instead. Skipped videos are not charged.

## `captionType` (type: `string`):

Choose which captions are accepted. Auto-generated captions are produced by YouTube's speech recognition and have no punctuation in many languages.

## Actor input object example

```json
{
  "videoUrls": [
    "https://www.youtube.com/watch?v=arj7oStGLkU",
    "https://youtu.be/iG9CE55wbtY"
  ],
  "maxVideosPerSource": 5,
  "languages": [
    "es",
    "en"
  ],
  "combinedFile": false,
  "fallbackToAnyLanguage": true,
  "captionType": "any"
}
```

# Actor output Schema

## `transcripts` (type: `string`):

All results of the run. Each item has a status field: only items with status 'success' contain a transcript and were charged.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/iG9CE55wbtY"
    ],
    "maxVideosPerSource": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("nokia2k/youtube-video-to-text").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "videoUrls": [
        "https://www.youtube.com/watch?v=arj7oStGLkU",
        "https://youtu.be/iG9CE55wbtY",
    ],
    "maxVideosPerSource": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("nokia2k/youtube-video-to-text").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "videoUrls": [
    "https://www.youtube.com/watch?v=arj7oStGLkU",
    "https://youtu.be/iG9CE55wbtY"
  ],
  "maxVideosPerSource": 5
}' |
apify call nokia2k/youtube-video-to-text --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nokia2k/youtube-video-to-text"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1MKtD8OQ5Q6Sw8rpL/builds/1YvmP4eQKA3dJRmkR/openapi.json