# YouTube Downloader - 8K/4K/1080p Video, MP3 Audio & Subtitles (`dami_studio/youtube-video-downloader`) Actor

The cheapest YouTube videos downloader in the store 💸. Download YouTube videos as MP4 in 8K, 4K, 1440p, 1080p, 720p, 480p or 360p, extract audio as MP3, and grab subtitles or transcripts. No login, cookies or API key. Pay per megabyte delivered - failed downloads are never charged.

- **URL**: https://apify.com/dami\_studio/youtube-video-downloader.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Videos, Social media, Developer tools
- **Stats:** 69 total users, 36 monthly users, 99.9% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$50.00 / 1,000 successful downloads

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Video & Audio Downloader — up to 8K, pay per megabyte

Download any public YouTube video as **MP4 — 360p all the way to 4320p (8K)** — or extract **audio as MP3**, with
metadata and optional subtitles. No login, no cookies, no API key. You pay **per megabyte actually
delivered** — so a 30-second clip costs a fraction of a cent, and you are never charged for a
download that fails.

Built on `yt-dlp` and run entirely on Apify's cloud. Point it at a URL, get a file.

***

### What you get

- **Real quality selection, up to 8K** — request 360p, 480p, 720p, 1080p, 1440p (2K), 2160p (4K) or 4320p (8K) and receive that quality.
- **Audio-only mode** — MP3 extraction for podcasts, transcription pipelines and music archives.
- **Full metadata** — title, channel, duration, view count, upload date, resolution, file size.
- **Subtitles and transcripts** — including auto-generated captions, converted to `.srt`.
- **Batch input** — pass many URLs in a single run.
- **A direct download link** for every file, plus the file in Apify storage.

***

### Quality and file size

Measured on a 10-minute 4K-source video, so you can predict cost before you run:

| Quality | Typical size (10 min) | Approx. per minute |
|---------|----------------------:|-------------------:|
| Audio (MP3) | 10 MB | ~1 MB |
| 360p | 46 MB | ~4.6 MB |
| 720p | 102 MB | ~10 MB |
| 1080p (Full HD) | 155 MB | ~15 MB |
| 1440p (2K) | 344 MB | ~34 MB |
| 2160p (4K) | 743 MB | ~74 MB |
| 4320p (8K) | 344 MB | ~34 MB |

All figures are measured from real downloads, not estimated. Verified with `ffprobe` on the
delivered files: a 4320p request returns a true **7680x4320** file, 1080p returns 1920x1080.

Sizes vary with the source video's bitrate — a static talking-head clip is far smaller than fast
motion at the same resolution.

***

### Pricing

Two charges: a small fee when a run starts, plus a per-megabyte fee for what you download.
**Nothing is charged for a failed or blocked download.**

| Apify plan tier | Per MB downloaded |
|-----------------|------------------:|
| Free | $0.0050 |
| Bronze | $0.0042 |
| Silver | $0.0033 |
| Gold | $0.0021 |
| Platinum | $0.0012 |
| Diamond | $0.00068 |

Actor start: **$0.0005** per run.

#### What that costs in practice (Free tier)

| Job | Size | You pay |
|-----|-----:|--------:|
| Short clip / Shorts | 2.5 MB | **$0.013** |
| 3 min at 360p | 13 MB | **$0.066** |
| 10 min at 360p | 46 MB | **$0.231** |
| 3.5 min at 720p | 21 MB | **$0.106** |
| 10 min at 1080p | 155 MB | **$0.776** |

#### Why per megabyte

Flat "per video" pricing forces one of two bad outcomes: short clips subsidise long ones, or long
downloads get refused. Charging per megabyte means **you pay for exactly what you receive** — a
30-second Short costs about a cent, and a long 1080p download is priced honestly rather than
blocked. It also means no artificial duration caps.

***

### How to use

1. Open the Actor and paste one or more YouTube URLs.
2. Choose a quality (or `audio` for MP3).
3. Click **Start**. Download links appear in the dataset when the run finishes.

#### Input

```json
{
  "urls": ["https://www.youtube.com/watch?v=aqz-KE-bpKQ"],
  "quality": "1080",
  "audioOnly": false,
  "subtitles": false,
  "subLangs": "en",
  "includeMetadata": true,
  "maxMegabytes": 1000
}
```

| Field | Type | Description |
|-------|------|-------------|
| `urls` | array | YouTube watch or Shorts links. Batch as many as you like. |
| `videoUrl` | string | A single URL, as an alternative to `urls`. |
| `quality` | string | `audio`, `360`, `480`, `720`, `1080`, `1440`, `2160`, `4320`. |
| `audioOnly` | boolean | Extract MP3 audio instead of video. |
| `subtitles` | boolean | Also download subtitles as `.srt`. |
| `subLangs` | string | Subtitle languages, e.g. `en` or `en,es`. |
| `includeMetadata` | boolean | Include title, channel, views, upload date. |
| `maxMegabytes` | integer | Safety limit (default 1000). Videos estimated above this are skipped **uncharged**, so you never get a surprise bill. Raise it for 4K/8K. |

#### Output

One dataset row per successful download:

```json
{
  "ok": true,
  "url": "https://www.youtube.com/watch?v=aqz-KE-bpKQ",
  "title": "Big Buck Bunny 60fps 4K - Official Blender Foundation Short Film",
  "channel": "Blender Foundation",
  "durationSeconds": 635,
  "requestedQuality": "1080",
  "resolution": "3840x2160",
  "format": "mp4",
  "fileSizeBytes": 155340000,
  "billedMegabytes": 156,
  "mediaKey": "aqz-KE-bpKQ.mp4",
  "mediaUrl": "https://api.apify.com/v2/key-value-stores/.../records/aqz-KE-bpKQ.mp4"
}
```

Failed URLs are written to the `ERRORS` record in the key-value store, so you can inspect them
without being charged.

***

### Frequently asked questions

**Can it really download 8K?**
Yes. Request 4320p and you get a true **7680x4320** file — verified with `ffprobe` on the output,
not just a label. On the same clip we measured 25 MB at 1080p, 166 MB at 4K and 344 MB at 8K.

**Do I need a YouTube account, cookies, or an API key?**
No. Supply a URL and nothing else.

**Am I charged if a download fails?**
No. Charges apply only to successfully delivered files. Blocked, unavailable and private videos cost
you nothing.

**How much does a typical download cost?**
About $0.013 for a short clip, $0.78 for a 10-minute 1080p video, and $1.72 for that same clip in
8K, on the Free tier - lower on higher Apify subscription tiers. You pay only for megabytes actually
delivered.

**Can I download audio only?**
Yes. Set `quality` to `audio` (or `audioOnly: true`) for an MP3 — roughly 1 MB per minute, so a
one-hour podcast is about 60 MB.

**Is there a length limit?**
No fixed duration limit. Use `maxMegabytes` to cap spend per run; anything above it is skipped
without charge.

**Can I download several videos at once?**
Yes — pass an array of URLs in `urls`.

**Does it support subtitles?**
Yes, including auto-generated captions, saved as `.srt` alongside the media.

**Where do the files go?**
Each file is stored in the run's key-value store with a direct `mediaUrl` link, and each dataset row
records the size actually billed.

***

### Limits and honest notes

- **Public videos only.** Private, members-only, purchase-required and age-restricted videos that
  need a signed-in account are not supported.
- **4K and 8K files are large.** Raise `maxMegabytes` (e.g. 5000) to allow them, and expect longer
  runs and proportionally higher per-megabyte cost.
- **Large downloads take time.** Use `maxMegabytes` to keep runs bounded.
- **Respect copyright.** Download only content you own or are permitted to use. You are responsible
  for how you use the files and for complying with YouTube's Terms of Service.

***

### Related Actors

- **YouTube Channel Scraper** — list every video on a channel
- **YouTube Comments Scraper** — comments with likes and replies
- **YouTube Playlist Scraper** — all videos in a playlist
- **Video & Audio Transcriber** — turn downloaded media into text

# Actor input Schema

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

One or more YouTube video URLs (or Shorts URLs).

## `videoUrl` (type: `string`):

A single YouTube URL (alternative to the array).

## `quality` (type: `string`):

Video quality to download. Choose 'audio' for MP3 only. 1440p, 4K and 8K are delivered when the source provides them, otherwise the next best quality is used. You are billed per megabyte delivered, so higher qualities cost proportionally more - raise maxMegabytes for 4K/8K.

## `audioOnly` (type: `boolean`):

Extract audio as MP3 instead of video.

## `subtitles` (type: `boolean`):

Also fetch subtitles/auto-captions as SRT.

## `subLangs` (type: `string`):

Comma-separated subtitle language codes (e.g. en,es). Used when subtitles are on.

## `includeMetadata` (type: `boolean`):

Return title, channel, duration, views, etc.

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

Optional. Leave default unless you want to route traffic through your own proxy.

## `maxMegabytes` (type: `integer`):

Safety limit per video. A video estimated above this size is skipped without any charge, so you never get a surprise bill. 4K and 8K files are large - raise this (e.g. 5000) to allow them.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=aqz-KE-bpKQ"
  ],
  "quality": "720",
  "audioOnly": false,
  "subtitles": false,
  "subLangs": "en",
  "includeMetadata": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxMegabytes": 1000
}
```

# Actor output Schema

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

Result rows / metadata are stored in the default dataset (one row per item).

## `files` (type: `string`):

Generated media/files (video, audio, images, captions) are stored in the default key-value store.

## `errors` (type: `string`):

Failed URL details are stored separately so they never trigger a result charge.

# 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/watch?v=aqz-KE-bpKQ"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/youtube-video-downloader").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/watch?v=aqz-KE-bpKQ"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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/watch?v=aqz-KE-bpKQ"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call dami_studio/youtube-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dami_studio/youtube-video-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aVAMAxTGRPbSMmmDD/builds/ALBKXkMnlKGEdGaC4/openapi.json