# YouTube Shorts Scraper — Data, Transcripts & Comments (`sicteg/youtube-shorts-scraper`) Actor

Scrape YouTube Shorts in bulk: video data (views, likes, publish date), the full spoken transcript with timestamps, and top comments - one row per Short, Excel-ready. Pay per Short delivered; no data, no charge.

- **URL**: https://apify.com/sicteg/youtube-shorts-scraper.md
- **Developed by:** [Alejandro Salamanca F SICTEG LTDA](https://apify.com/sicteg) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 short with transcripts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 Shorts Scraper — Data, Transcripts & Comments

### Video walkthrough

A 50-second recording of a real run (one channel, 8 Shorts, 20 comments each): https://youtu.be/0CwQeIuzTg0

Paste Shorts links or a whole channel and get **one row per Short** with three things most tools sell
separately: the video data, the spoken transcript, and the comments.

### What you get

**One row per Short, 20 flat columns** (nothing nested — exports cleanly to Excel/CSV):

| Group | Fields |
|---|---|
| Video data | `video_id`, `url`, `titulo`, `canal`, `canal_url`, `duracion_s`, `fecha_publicacion`, `vistas`, `me_gusta`, `miniatura_url` |
| Spoken transcript | `idioma`, `subtitulo_automatico`, `es_traduccion`, `fragmentos_total`, `texto_con_tiempos`, `texto_completo` |
| Comments | `comentarios_incluidos`, `comentarios_texto` |
| Status | `estado`, `error` |

The transcript comes in the **video's original language**, not one of YouTube's ~20 automatic machine
translations — and every line carries a timestamp (`[00:01.64] ...`).

Comments arrive as one line each, with the author and its like count:
`@ana (212 me gusta): el mejor video`.

### Why this one

The biggest Shorts scraper in the Store returns the video data and tells you *whether* a Short has
captions and *how many* comments it has — but **not the text and not the comments**. Here you get all
of it in a single run, from one input.

### Input

| Field | Meaning |
|---|---|
| `startUrls` | Shorts links, video links, or channel URLs (a channel returns every Short on its Shorts tab) |
| `maxShortsPorEnlace` | Cap per link (default 10) |
| `comentariosPorShort` | Top comments per Short (default 20; `0` = no comments) |
| `incluirTexto` | Include the transcript (default on) |
| `usarUnblockerParaTexto` | Optional fallback if YouTube rate-limits |
| `enParalelo` | How many Shorts to process at once (1–8, default 4). Higher is faster and cheaper per Short |
| `proxyConfiguration` | Residential proxy by default — YouTube limits per IP |

### Integrations (copy-paste)

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("sicteg/youtube-shorts-scraper").call(run_input={
    "startUrls": ["https://www.youtube.com/@MrBeast/shorts"],
    "maxShortsPorEnlace": 50,
    "comentariosPorShort": 20,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["titulo"], row["vistas"], len(row["texto_completo"]))
```

**n8n**: add an Apify node → *Run Actor and get dataset* → Actor `sicteg/youtube-shorts-scraper`, paste the same
JSON as input. One item per Short comes back, ready for a summarizer or a repurposing workflow.

**Google Sheets / Excel**: run it, download the dataset as CSV/XLSX, or use the Apify Google Sheets integration. No
nested arrays, so nothing breaks on import.

**Ready-to-run example script** (no dependencies, exports straight to CSV): it lives in this repository —
<https://github.com/sictegltda-cyber/youtube-shorts-transcripts-to-csv> — with the three traps this Actor
handles documented in its README.

**Write-up with the measurements**: <https://sictegltda.com/youtube-shorts-transcripts.html>

### Price

Pay per result, only for what you actually receive:

- **$5.00 per 1,000 Shorts** (data + transcript) → `$0.005` each.
- **$0.20 per 1,000 comments** (add-on) → `$0.0002` each.
- Shorts without captions are reported as `sin_subtitulo` and **not charged**.

A full row with the transcript and 20 comments costs **$0.009**.

### How it behaves

- Residential proxy rotating on every request, with retries on rate limits: Shorts without captions are
  reported instead of failing the run.
- Tested on real channels: 3 channels in English and Spanish, transcripts, dates, likes and comments all
  matching what YouTube shows.
- Use it from n8n, Make, Zapier or your own code through the Apify API.

***

### 🇪🇸 En español

Pega enlaces de Shorts o un canal completo y obtén **una fila por Short** con los datos del video, el
texto hablado con tiempos (en el idioma original, no una traducción automática) y los comentarios.

Se cobra solo por lo que se entrega: **US$5 por cada 1.000 Shorts** (datos + texto) y **US$0,20 por cada
1.000 comentarios**. Los Shorts sin subtítulo se reportan y no se cobran.

20 columnas planas: sale limpio en Excel, sin arreglos anidados.

# Actor input Schema

## `startUrls` (type: `array`):

Shorts links, video links or channel URLs. A channel URL returns every Short on its Shorts tab. Example: https://www.youtube.com/@MrBeast/shorts

## `maxShortsPorEnlace` (type: `integer`):

Cap per start URL: each link returns up to this many Shorts (its most recent ones).

## `comentariosPorShort` (type: `integer`):

How many top comments to return per Short. 0 = no comments (cheaper). Every comment delivered is charged.

## `incluirTexto` (type: `boolean`):

On (default): every Short also returns its spoken text with timestamps, in the video's original language (not a machine translation).

## `pausaEntrePedidos` (type: `number`):

Increase it if YouTube starts rate-limiting.

## `usarUnblockerParaTexto` (type: `boolean`):

Optional fallback. Default (off) uses residential proxy only, which is cheaper. Turn on if you see many blocked requests.

## `enParalelo` (type: `integer`):

How many Shorts to process concurrently (1-8). Higher is faster and cheaper per Short; lower it if YouTube starts rate-limiting.

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

YouTube rate-limits requests per IP. Residential proxy rotates the IP on every request.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.youtube.com/@MrBeast/shorts"
  ],
  "maxShortsPorEnlace": 10,
  "comentariosPorShort": 20,
  "incluirTexto": true,
  "pausaEntrePedidos": 0.5,
  "usarUnblockerParaTexto": false,
  "enParalelo": 4,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.youtube.com/@MrBeast/shorts"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": ["https://www.youtube.com/@MrBeast/shorts"] }

# Run the Actor and wait for it to finish
run = client.actor("sicteg/youtube-shorts-scraper").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 '{
  "startUrls": [
    "https://www.youtube.com/@MrBeast/shorts"
  ]
}' |
apify call sicteg/youtube-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sicteg/youtube-shorts-scraper"
        }
    }
}
```

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/Gamu8bD9gZ26IJWWy/builds/rf8a4dGZLS87ARzjY/openapi.json