# Media Downloader - All-in-One Video, Audio and Metadata (`khadinakbar/all-in-one-media-downloader`) Actor

Download permitted public videos or audio from many supported media sites with yt-dlp, save files to Apify key-value storage, and return clean MCP-ready metadata rows with honest success, partial, empty, and upstream-failed summaries.

- **URL**: https://apify.com/khadinakbar/all-in-one-media-downloader.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 media downloadeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Media Downloader - All-in-One Video, Audio and Metadata

Download permitted public videos or audio from many supported media platforms into Apify key-value storage, then get one clean dataset row per media item with metadata, file keys, direct source URLs when available, and an honest run summary.

This actor is built for media operations teams, content owners, social media managers, editors, researchers, and AI agents that need a single URL-in, structured-media-out tool. It uses `yt-dlp` and `ffmpeg` for broad site coverage, enforces duration and file-size caps, stores the downloaded media in the default Apify key-value store, and writes `OUTPUT` plus `RUN_SUMMARY` for every terminal path.

Use it only when you own the media, control the account, have permission from the rights holder, or have another lawful basis to download the submitted files.

### What You Get

| Capability | Details |
|---|---|
| Video download | Save supported public videos as MP4, WebM, or the best source container. |
| Audio download | Save source audio as M4A, MP3, or the best available audio format. |
| Metadata-only mode | Probe URLs cheaply and return metadata plus expiring direct media URLs when exposed by the source. |
| Broad platform coverage | Works with many `yt-dlp` supported sites including YouTube, Vimeo, Dailymotion, TikTok, Instagram, Reddit, X/Twitter, SoundCloud, Bandcamp, Pinterest, Facebook, Threads, Bilibili, Rumble, Imgur, Tumblr, and many niche video/audio hosts. |
| Persistent Apify storage | Saves media files and raw metadata JSON to the default key-value store. |
| Agent-ready rows | Returns flat, predictable dataset records with source URL, platform, title, creator, duration, quality, file key, status, and error. |
| Honest outcomes | Uses `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR` in `OUTPUT` and `RUN_SUMMARY`. |

### Input

| Field | Type | Default | Notes |
|---|---|---:|---|
| `startUrls` | URL list | required | Media page URLs as request-list objects. |
| `authorizationConfirmed` | boolean | false | Must be true before any probing or download runs. |
| `downloadMode` | enum | `video` | `video`, `audio`, or `metadataOnly`. |
| `preferredQuality` | enum | `720p` | Maximum video quality for video mode. |
| `preferredContainer` | enum | `mp4` | `mp4`, `webm`, or `any`. |
| `audioFormat` | enum | `m4a` | `m4a`, `mp3`, or `best`. |
| `includePlaylists` | boolean | false | Expand playlist-like URLs up to `maxItems`. |
| `maxItems` | integer | 20 | Hard cap from 1 to 500 items and billable success events. |
| `maxDurationMinutes` | integer | 60 | Skip longer media before downloading. |
| `maxFileSizeMb` | integer | 250 | Delete and skip files above this cap. |
| `includeMetadataJson` | boolean | true | Save raw `yt-dlp` metadata JSON. |
| `cookiesTxt` | secret string | empty | Optional Netscape cookies.txt for accounts you control. |
| `proxyConfiguration` | object | residential Apify Proxy | Override only if your target media works elsewhere. |

### Example Input

```json
{
  "startUrls": [
    { "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
    { "url": "https://vimeo.com/76979871" }
  ],
  "authorizationConfirmed": true,
  "downloadMode": "video",
  "preferredQuality": "720p",
  "preferredContainer": "mp4",
  "maxItems": 10,
  "maxDurationMinutes": 15,
  "maxFileSizeMb": 150
}
````

### Output

One dataset row is returned per submitted URL or expanded playlist entry:

```json
{
  "sourceUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "canonicalUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "platform": "youtube",
  "extractor": "Youtube",
  "mediaId": "dQw4w9WgXcQ",
  "title": "Example video",
  "creator": "Example Channel",
  "durationSeconds": 213,
  "thumbnailUrl": "https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg",
  "downloadMode": "video",
  "preferredQuality": "720p",
  "formatExtension": "mp4",
  "qualityLabel": "720p",
  "fileKey": "video-dqw4w9wgxcq-example-video.mp4",
  "fileUrl": "https://api.apify.com/v2/key-value-stores/STORE/records/video-dqw4w9wgxcq-example-video.mp4",
  "fileSizeBytes": 12345678,
  "contentType": "video/mp4",
  "metadataKey": "metadata-dqw4w9wgxcq.json",
  "status": "success",
  "error": null,
  "warnings": [],
  "scrapedAt": "2026-07-15T12:00:00Z"
}
```

Downloaded files are in the default key-value store. Use `fileKey` or `fileUrl` for the saved media file and `metadataKey` or `metadataUrl` for raw platform metadata.

### Pricing

Pay per event plus Apify platform usage:

- `$0.00005` actor start.
- `$0.015` per successfully downloaded video or audio file.
- `$0.004` per successful metadata-only URL.

Failed URLs, skipped files, unsupported URLs, too-large files, and invalid-input exits are not charged for media success events. Apify platform usage for compute, storage, and proxy traffic is additional.

### MCP And AI Agent Use

Tool description draft:

Download authorized public media from many supported sites to Apify storage. Use for video/audio URLs from YouTube, Vimeo, TikTok, Instagram, Reddit, SoundCloud, and similar pages. Do not use for DRM, private, transcript, comment, or profile scraping. Returns one row per URL with platform, title, fileKey, directMediaUrl, status, and errors. Charged $0.015 per saved file.

The output is intentionally flat and compact. Agents can inspect a few rows, fetch the persisted file from the key-value store, and read `OUTPUT` to decide whether the run was complete, partial, empty, invalid, or blocked upstream.

### Reliability Notes

Different platforms expose media differently. Public static files and mainstream video hosts usually work well. Some social networks rotate signatures, require cookies, block datacenter IPs, restrict regions, or remove media without notice. The actor uses residential proxy by default and accepts optional cookies.txt for accounts you control, but it will not bypass DRM, private-account boundaries, paywalls, or platform access controls.

When useful output exists but some URLs fail, the run finishes as `PARTIAL`. When valid URLs all fail because the upstream extraction route is blocked or unavailable, the run honestly ends as `UPSTREAM_FAILED`. User-fixable issues such as missing authorization confirmation or missing URLs end as `INVALID_INPUT` with no media event charges.

### Legal

Only download media you own, media you have permission to download, or media you are otherwise legally allowed to copy. You are responsible for complying with copyright law, privacy law, each platform's terms, and any rules that apply to your use case. This actor is not affiliated with, endorsed by, or sponsored by YouTube, TikTok, Instagram, Meta, Reddit, X, Vimeo, Dailymotion, SoundCloud, or any other supported platform.

### Related Single-Platform Actors

For platform-specific enrichment or no-watermark workflows, use the dedicated actors in this portfolio when they fit better:

- TikTok No Watermark Downloader
- Instagram Video Downloader
- Reddit Media Downloader
- Vimeo Video Downloader
- Dailymotion Video Downloader
- YouTube Video Downloader

This all-in-one actor is the broad router for mixed URL batches and normalized media storage.

# Actor input Schema

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

Full media page URLs to process, for example https://www.youtube.com/watch?v=dQw4w9WgXcQ or a public Vimeo, TikTok, Instagram, Reddit, SoundCloud, Dailymotion, Pinterest, or X/Twitter media URL. Accepts Apify request-list objects with a url field. Defaults to one sample public YouTube URL. NOT a keyword search box or a way to access private media without permission.

## `authorizationConfirmed` (type: `boolean`):

Confirms that you own the media, have permission from the rights holder, or are otherwise legally allowed to download it. The actor stops with INVALID\_INPUT if this is false. Defaults to false so accidental runs do not download files. NOT a bypass for copyright, paywalls, DRM, private accounts, or access controls.

## `downloadMode` (type: `string`):

What to save for each URL. video saves a playable video file, audio saves audio only, and metadataOnly extracts metadata plus an expiring direct media URL when available. Defaults to video. NOT a transcript, comments, or profile scraper.

## `preferredQuality` (type: `string`):

Maximum video height when downloadMode is video. Choose 360p, 480p, 720p, 1080p or best. Defaults to 720p to keep files and platform usage manageable. NOT an upscaler; it cannot create higher quality than the source provides.

## `preferredContainer` (type: `string`):

Preferred container for video downloads. mp4 is the most compatible option, webm keeps many native web formats, and any lets yt-dlp choose. Defaults to mp4. NOT guaranteed if the source only provides another format.

## `audioFormat` (type: `string`):

Audio output when downloadMode is audio. m4a is fast and compatible, mp3 transcodes with ffmpeg, and best keeps the best source audio. Defaults to m4a. Ignored for video and metadata-only runs.

## `includePlaylists` (type: `boolean`):

When true, playlist-like URLs are expanded into individual media URLs up to maxItems. Defaults to false so a single URL means one media item. Use this for YouTube playlists or supported albums only when you expect multiple files. NOT a site crawler.

## `maxItems` (type: `integer`):

Maximum number of URLs or playlist entries to process in one run. Defaults to 20 and accepts 1 to 500. This also caps the number of billable success events. NOT a guaranteed result count if some URLs are private, too large, removed, or unsupported.

## `maxDurationMinutes` (type: `integer`):

Skip media longer than this many minutes before downloading. Defaults to 60 minutes and accepts 1 to 720. Use this to avoid podcasts, livestreams, or very long recordings. NOT a clipper; the actor downloads the full source item if it passes this cap.

## `maxFileSizeMb` (type: `integer`):

Delete and mark a download as skipped if the final file is larger than this limit. Defaults to 250 MB and accepts 1 to 1000. Lower this for agent workflows where small files matter. NOT a compression target.

## `includeMetadataJson` (type: `boolean`):

Save raw yt-dlp metadata JSON for each successfully probed URL to the key-value store. Useful for audits, platform-specific fields, and downstream processing. Defaults to true. NOT required for the dataset row, which always includes concise normalized metadata.

## `cookiesTxt` (type: `string`):

Optional Netscape cookies.txt content for media you are allowed to access with your own logged-in session. Paste only cookies you are authorized to use. Leave empty for public media. NOT a username, password, or bypass for DRM/paywalls/private content.

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

Apify proxy used for media page requests. Residential proxies are enabled by default because social and video platforms often rate-limit datacenter IPs. Change only when your target media works from another network. NOT required for direct public files that allow datacenter traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "authorizationConfirmed": false,
  "downloadMode": "video",
  "preferredQuality": "720p",
  "preferredContainer": "mp4",
  "audioFormat": "m4a",
  "includePlaylists": false,
  "maxItems": 20,
  "maxDurationMinutes": 60,
  "maxFileSizeMb": 250,
  "includeMetadataJson": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `mediaRows` (type: `string`):

Structured dataset rows with metadata, direct URLs, file keys, status, and errors.

## `downloadedFiles` (type: `string`):

Downloaded media files and raw metadata JSON in the default key-value store.

## `runSummary` (type: `string`):

Compact OUTPUT record with outcome, counts, warnings, and charge counters.

## `runDiagnostics` (type: `string`):

Detailed RUN\_SUMMARY record with input counts, platform breakdown, validation errors, safe per-target errors, and billing counters.

# 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": [
        {
            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
        }
    ],
    "downloadMode": "video",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/all-in-one-media-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 = {
    "startUrls": [{ "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ" }],
    "downloadMode": "video",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/all-in-one-media-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 '{
  "startUrls": [
    {
      "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
    }
  ],
  "downloadMode": "video",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/all-in-one-media-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/all-in-one-media-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Media Downloader - All-in-One Video, Audio and Metadata",
        "description": "Download permitted public videos or audio from many supported media sites with yt-dlp, save files to Apify key-value storage, and return clean MCP-ready metadata rows with honest success, partial, empty, and upstream-failed summaries.",
        "version": "0.1",
        "x-build-id": "FedVnxAMDsLCKu0r2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~all-in-one-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-all-in-one-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~all-in-one-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-all-in-one-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~all-in-one-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-all-in-one-media-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls",
                    "authorizationConfirmed"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Media page URLs",
                        "type": "array",
                        "description": "Full media page URLs to process, for example https://www.youtube.com/watch?v=dQw4w9WgXcQ or a public Vimeo, TikTok, Instagram, Reddit, SoundCloud, Dailymotion, Pinterest, or X/Twitter media URL. Accepts Apify request-list objects with a url field. Defaults to one sample public YouTube URL. NOT a keyword search box or a way to access private media without permission.",
                        "items": {
                            "type": "object"
                        }
                    },
                    "authorizationConfirmed": {
                        "title": "I have permission to download these media files",
                        "type": "boolean",
                        "description": "Confirms that you own the media, have permission from the rights holder, or are otherwise legally allowed to download it. The actor stops with INVALID_INPUT if this is false. Defaults to false so accidental runs do not download files. NOT a bypass for copyright, paywalls, DRM, private accounts, or access controls.",
                        "default": false
                    },
                    "downloadMode": {
                        "title": "Download mode",
                        "enum": [
                            "video",
                            "audio",
                            "metadataOnly"
                        ],
                        "type": "string",
                        "description": "What to save for each URL. video saves a playable video file, audio saves audio only, and metadataOnly extracts metadata plus an expiring direct media URL when available. Defaults to video. NOT a transcript, comments, or profile scraper.",
                        "default": "video"
                    },
                    "preferredQuality": {
                        "title": "Maximum video quality",
                        "enum": [
                            "360p",
                            "480p",
                            "720p",
                            "1080p",
                            "best"
                        ],
                        "type": "string",
                        "description": "Maximum video height when downloadMode is video. Choose 360p, 480p, 720p, 1080p or best. Defaults to 720p to keep files and platform usage manageable. NOT an upscaler; it cannot create higher quality than the source provides.",
                        "default": "720p"
                    },
                    "preferredContainer": {
                        "title": "Preferred video container",
                        "enum": [
                            "mp4",
                            "webm",
                            "any"
                        ],
                        "type": "string",
                        "description": "Preferred container for video downloads. mp4 is the most compatible option, webm keeps many native web formats, and any lets yt-dlp choose. Defaults to mp4. NOT guaranteed if the source only provides another format.",
                        "default": "mp4"
                    },
                    "audioFormat": {
                        "title": "Audio format",
                        "enum": [
                            "m4a",
                            "mp3",
                            "best"
                        ],
                        "type": "string",
                        "description": "Audio output when downloadMode is audio. m4a is fast and compatible, mp3 transcodes with ffmpeg, and best keeps the best source audio. Defaults to m4a. Ignored for video and metadata-only runs.",
                        "default": "m4a"
                    },
                    "includePlaylists": {
                        "title": "Expand playlists or multi-video pages",
                        "type": "boolean",
                        "description": "When true, playlist-like URLs are expanded into individual media URLs up to maxItems. Defaults to false so a single URL means one media item. Use this for YouTube playlists or supported albums only when you expect multiple files. NOT a site crawler.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum media items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of URLs or playlist entries to process in one run. Defaults to 20 and accepts 1 to 500. This also caps the number of billable success events. NOT a guaranteed result count if some URLs are private, too large, removed, or unsupported.",
                        "default": 20
                    },
                    "maxDurationMinutes": {
                        "title": "Max duration in minutes",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "Skip media longer than this many minutes before downloading. Defaults to 60 minutes and accepts 1 to 720. Use this to avoid podcasts, livestreams, or very long recordings. NOT a clipper; the actor downloads the full source item if it passes this cap.",
                        "default": 60
                    },
                    "maxFileSizeMb": {
                        "title": "Max file size in MB",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Delete and mark a download as skipped if the final file is larger than this limit. Defaults to 250 MB and accepts 1 to 1000. Lower this for agent workflows where small files matter. NOT a compression target.",
                        "default": 250
                    },
                    "includeMetadataJson": {
                        "title": "Save raw metadata JSON",
                        "type": "boolean",
                        "description": "Save raw yt-dlp metadata JSON for each successfully probed URL to the key-value store. Useful for audits, platform-specific fields, and downstream processing. Defaults to true. NOT required for the dataset row, which always includes concise normalized metadata.",
                        "default": true
                    },
                    "cookiesTxt": {
                        "title": "Cookies.txt (optional)",
                        "type": "string",
                        "description": "Optional Netscape cookies.txt content for media you are allowed to access with your own logged-in session. Paste only cookies you are authorized to use. Leave empty for public media. NOT a username, password, or bypass for DRM/paywalls/private content."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy used for media page requests. Residential proxies are enabled by default because social and video platforms often rate-limit datacenter IPs. Change only when your target media works from another network. NOT required for direct public files that allow datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
