# YouTube Shorts Downloader Pro (`xtech/youtube-shorts-downloader-pro`) Actor

Save authorized YouTube Shorts in batches with resolution control, per-URL diagnostics, saved-file links, and optional proxy recovery for regional or rate-limited sources.

- **URL**: https://apify.com/xtech/youtube-shorts-downloader-pro.md
- **Developed by:** [Xtech](https://apify.com/xtech) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 95 total users, 1 monthly users, 8.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## YouTube Shorts Downloader Pro

Save YouTube Shorts that you own or are allowed to download, in bulk and at the quality you choose.

### What it does

- Process several Shorts URLs in one run (direct YouTube video URLs are also accepted for compatibility)
- Choose a maximum resolution from 144p to 1440p
- Return the title, channel, duration, thumbnail, views, and download result for every Short
- Save successful files in the run’s storage
- Use optional cookies for content you are authorized to access
- Use a proxy if a video is unavailable from your location or requests are rate-limited

### Get started

Paste one or more Shorts URLs, pick a resolution, and choose how many should run at once.

```json
{
  "urls": ["https://www.youtube.com/shorts/vVoMLnsbQqE"],
  "resolution": "720p",
  "max_concurrent": 3
}
```

### Ready-to-run presets

Low-cost single Short:

```json
{
  "urls": ["https://www.youtube.com/shorts/vVoMLnsbQqE"],
  "resolution": "480p",
  "max_concurrent": 1,
  "proxyConfiguration": {"useApifyProxy": false}
}
```

Small approved batch:

```json
{
  "urls": [
    "https://www.youtube.com/shorts/vVoMLnsbQqE",
    "https://www.youtube.com/shorts/G56v017spr0"
  ],
  "resolution": "720p",
  "max_concurrent": 3
}
```

Authorized recovery for a blocked or region-limited source:

```json
{
  "urls": ["https://www.youtube.com/shorts/vVoMLnsbQqE"],
  "resolution": "720p",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Add authorized cookies only in the secret `cookies` input; never place them in a shared task or README.

### Best for

- Saving Shorts that you own or are authorized to use for social, editorial, or archival workflows
- Processing a small batch with per-URL success and error records
- Retrying location- or rate-limit-related failures with an explicitly selected proxy

### Results

Each input URL produces a dataset item. Successful results include the saved-file link and video details. If a Short cannot be downloaded, the item explains why so you can adjust the URL, access settings, or proxy choice.

Failed URLs remain in the dataset with `downloadSuccess: false`. If every URL fails, the run is marked **FAILED** after those rows are written. Each run also writes a `RUN_SUMMARY` key-value record with requested, successful, failed, resolution, proxy, and cookie-usage counts. The Store test preset keeps proxy traffic disabled to control cost; Residential proxy traffic can materially increase cost, so enable it explicitly only when YouTube blocks the direct path.

#### Example output

```json
{
  "url": "https://www.youtube.com/shorts/vVoMLnsbQqE",
  "video_id": "vVoMLnsbQqE",
  "title": "Example Short",
  "downloadSuccess": true,
  "duration": 28,
  "aspect_ratio": "9:16",
  "download_url": "https://api.apify.com/v2/key-value-stores/.../records/vVoMLnsbQqE",
  "error": null
}
```

Every input gets one dataset item. This makes partial batches easy to inspect: keep successful `download_url` values and use the corresponding `error` and `error_type` fields to retry only the failed URLs.

Malformed or non-YouTube URLs are retained as `Invalid YouTube URL` error rows and
are not sent through yt-dlp retries. Cookies are a secret textarea input and are
written only to a short-lived, permission-restricted temporary file during the
run.

Only download content that you own or have permission to save. Availability, formats, and access rules are determined by YouTube and the video owner.

### Troubleshooting

- YouTube JavaScript challenge: the Actor bundles yt-dlp's EJS challenge solver and enables the bundled Deno runtime automatically. If YouTube still asks for sign-in, use authorized cookies or retry with the Residential proxy path below.
- **Invalid YouTube URL:** use a complete `/shorts/VIDEO_ID`, `/watch?v=VIDEO_ID`, `/embed/VIDEO_ID`, or `/live/VIDEO_ID` URL. Invalid rows are recorded without spending extraction retries.
- **Age-restricted or private video:** provide authorized Netscape-format cookies in the secret `cookies` field. Cookies are removed after the run.
- **Bot check, 403, or location failure:** retry with `proxyConfiguration.useApifyProxy: true` and the Residential group. Proxy traffic can increase cost, so enable it only when needed.
- **Only some URLs failed:** inspect each failed dataset item and rerun those URLs; successful downloads do not need to be repeated.

### Related Actors

- [YouTube Video Downloader](https://apify.com/xtech/youtube-video-downloader) — download longer-form YouTube videos with the same per-URL result pattern.
- [YouTube Transcript Scraper Pro](https://apify.com/xtech/youtube-transcript-scraper-pro) — turn approved videos into searchable transcripts.

# Actor input Schema

## `urls` (type: `array`):

Enter one or more YouTube Shorts or compatible YouTube video URLs to download. You can paste individual Shorts URLs or mix supported formats.

**Supported formats:**

- Shorts: `https://www.youtube.com/shorts/...`
- Mobile Shorts: `https://youtube.com/shorts/...`
- Short URLs: `https://youtu.be/...`
- Watch URLs: `https://www.youtube.com/watch?v=...`
- Embed or live URLs: `https://www.youtube.com/embed/...` or `/live/...`

## `resolution` (type: `string`):

Select the preferred video resolution for Shorts downloads. Most Shorts are available in vertical formats optimized for mobile viewing.

## `max_concurrent` (type: `integer`):

Maximum number of Shorts to download simultaneously. Since Shorts are typically smaller files, you can safely use higher values for faster bulk downloads.

## `cookies` (type: `string`):

Paste cookies.txt content (Netscape format) for age-restricted or region-blocked Shorts.

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

Enable Apify Proxy if downloads fail from your region or YouTube rate-limits requests.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/shorts/vVoMLnsbQqE"
  ],
  "resolution": "720p",
  "max_concurrent": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Items stored in the default dataset.

# 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 = {
    "urls": [
        "https://www.youtube.com/shorts/vVoMLnsbQqE"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtech/youtube-shorts-downloader-pro").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 = {
    "urls": ["https://www.youtube.com/shorts/vVoMLnsbQqE"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("xtech/youtube-shorts-downloader-pro").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 '{
  "urls": [
    "https://www.youtube.com/shorts/vVoMLnsbQqE"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call xtech/youtube-shorts-downloader-pro --silent --output-dataset

```

## MCP server setup

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

```

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/sgRGTrqZQvd4WirKt/builds/jbhWhZWJCsEGL60MJ/openapi.json