# Twitch VOD Downloader (`agentx/twitch-vod-downloader`) Actor

Process one publicly accessible Twitch VOD or clip for structured metadata and an optional stored video file.

- **URL**: https://apify.com/agentx/twitch-vod-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Agents, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

Turn one playable Twitch VOD or clip into a stable Dataset row, with an optional copy of the media saved to Apify storage.

- Accepts a single public VOD or Clip address per run.
- Separates fast metadata inspection from file-producing download modes.
- Surfaces 39 normalized fields even when Twitch leaves some values unavailable.
- Deliberately omits chat and comment collection from the public controls.

**[Open the Actor dashboard](https://apify.com/agentx/twitch-video-downloader)**

**[Inspect the REST API](https://apify.com/agentx/twitch-video-downloader/api)**

### Why Choose This API

Twitch recordings and clips use different page forms, yet downstream systems usually need one predictable record. This Actor converts a supported Twitch page into the same identifiers, creator details, timestamps, dimensions, counters, artwork, and provenance fields used throughout the AgentX video family.

Choose `metadata` when the page facts are the product. Choose a quality tier only when your workflow is allowed to retain the media. The requested tier is a preference: Twitch decides which renditions exist, and the downloader selects from those real choices.

Scope is intentionally narrow. The Actor does not enumerate a channel, watch a live schedule, replay Twitch chat, locate clips by game, authenticate as a subscriber, or archive a collection. A VOD or clip must already be known and publicly playable.

### Quick Start Guide

Start with this request:

```json
{
  "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu",
  "video_quality": "metadata"
}
```

Swap in a VOD you are permitted to process. A Twitch Clip URL is also within the documented contract. Verify the chosen page in a private browser window; a working test must play without a Twitch account or subscription.

Run metadata first and match the ID, channel, title, duration, and preview image against the page. Only then select `low`, `medium`, or `high`. A channel landing page, directory, collection, deleted broadcast, or subscriber-only recording is an invalid test for this single-item interface.

### Input Parameters

| Field | Value | Required | Behavior |
|---|---|---:|---|
| `video_url` | string | Yes | Public Twitch VOD or Clip page to process. |
| `video_quality` | string | No | `metadata`, `low`, `medium`, or `high`; omission behaves as metadata mode. |

`video_url` is the only mandatory property and its displayed sample is a public clip. `video_quality` intentionally has neither prefill nor example, so an optional control never silently changes the caller’s request.

Unknown keys fail schema validation. There are no fields for cookies, credentials, channel names, chat, comments, pagination, dates, geography, or a URL list.

### Output Data Schema

Each successful item can expose the following groups:

| Group | Dataset keys |
|---|---|
| Identity and artwork | `thumbnail`, `id`, `platform`, `title`, `description` |
| Timing and owner | `duration`, `published_at`, `author`, `author_id`, `author_url` |
| Taxonomy and reach | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media facts | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Audit fields | `comments`, `processed_at`, `processor` |

| Source and availability | `source_url`, `media_type`, `live_status`, `availability`, `age_limit`, `language` |
| Creator reach | `followers`, `is_verified` |
| File and captions | `file_ext`, `file_size`, `saves_count`, `subtitles`, `chapters` |
An abbreviated illustrative item is:

```json
{
  "id": "0000000000",
  "platform": "Twitch:vod",
  "title": "Illustrative Twitch broadcast",
  "author": "illustrative_channel",
  "thumbnail": "https://example.com/twitch-preview.jpg",
  "comments": [],
  "video": ""
}
```

This is a contract example, not captured Twitch data. Empty or null fields mean the extractor did not receive that value. `video` stays empty in metadata mode. `comments` is reserved for shape compatibility and does not represent Twitch chat.

### Integration Examples

The same VOD-shaped request can be submitted with HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~twitch-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu","video_quality":"metadata"}'
```

The matching MCP declaration keeps the identical arguments:

```json
{
  "mcpServers": {
    "twitch-media": {
      "url": "https://mcp.apify.com?tools=agentx/twitch-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu",
    "video_quality": "metadata"
  }
}
```

Never commit an Apify token. Review the [hosted MCP guide](https://docs.apify.com/integrations/mcp) before connecting an agent or automation.

### Pricing & Cost Calculator

| Event | Trigger | Declared amount |
|---|---|---:|
| `actor_usage` | Metered compute, proxy, and storage consumption | $0.00001 |
| `metadata` | A processed item without media storage | $0.09 |
| `download` | A processed item whose video is stored | $0.30 |

Therefore the smallest declared metadata case is $0.09 plus metered usage; the smallest declared download case is $0.30 plus metered usage.

### Use Cases & Applications

An authorized streamer can index individual VODs for an internal library. A research team can preserve the title, channel, duration, artwork, and source ID of a cited broadcast. Editors can hand a permitted clip file to a review queue. Speech systems can route an allowed recording to transcription after storage.

For longitudinal work, schedule the exact URL again and compare saved records outside this Actor. It does not discover new broadcasts or calculate deltas itself.

### Limits & Troubleshooting

Availability changes frequently on Twitch. Deletion, clip expiry, subscriber gates, account prompts, regional limits, age gates, absent renditions, throttling, ads, or extractor changes can prevent a result. No public input supplies authentication or a country route.

When metadata fails, confirm the precise VOD or Clip URL still plays privately and is not merely a channel or collection. Retry metadata before escalating. When metadata succeeds but no stored URL appears, verify the selected mode, logs, and key-value storage.

A release regression set should include one public VOD, one public Clip, a channel URL expected to fail, a removed item, and one permitted download. Capture the extractor key, media ID, requested mode, terminal status, and storage outcome.

### FAQ

#### Will it crawl every broadcast from a channel?

No. The interface processes one known media page.

#### Is a live channel supported?

Live capture is outside this public VOD-and-Clip contract. Use a live-stream-specific Actor.

#### Are Twitch chat messages returned?

No. Chat and comments have no public input and the reserved array is ordinarily empty.

#### Can it unlock subscriber archives?

No authentication field is provided, so protected recordings are outside scope.

#### What does the high setting guarantee?

It expresses a preference, not a fixed resolution. Available Twitch renditions control the file.

#### Why is a counter null rather than zero?

Null means unavailable; zero would be a measured value.

#### Can I send a batch of URLs?

No. Submit distinct runs or orchestrate them externally.

#### Should I prefer a VOD or a Clip address?

Prefer a Clip when you need a stable reference. Channel VODs are removed on Twitch's retention schedule, so an archived broadcast can disappear within weeks, while a Clip persists as long as the channel does. Both forms resolve through the same contract, and `platform` records which one was processed.

### Legal & Responsible Use

Only process broadcasts or clips you have authority to access and retain. You are responsible for Twitch terms, creator rights, copyright, privacy, local law, and deletion obligations.

### Related Tools

- [Live Stream Transcript](https://apify.com/agentx/live-stream-transcript) targets permitted real-time speech.
- [Video Transcript](https://apify.com/agentx/video-transcript) turns allowed recordings into text.
- [Video Captions Downloader](https://apify.com/agentx/video-captions-downloader) works with published caption tracks.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) offers a multi-host entry point.

### Support & Community

- [AgentX community](https://t.me/Apify_Actor)
- [Contact AgentX](https://t.me/AiAgentApi)
- [Actor dashboard](https://apify.com/agentx/twitch-video-downloader)
- [REST API reference](https://apify.com/agentx/twitch-video-downloader/api)
- [MCP documentation](https://docs.apify.com/integrations/mcp)

Support requests should include the stable Actor ID, a redacted source URL, the submitted input, and the run ID.

**[Open the Actor dashboard](https://apify.com/agentx/twitch-video-downloader)**

**[Inspect the REST API](https://apify.com/agentx/twitch-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Twitch VOD or clip URL.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu"
}
```

# Actor output Schema

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

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/twitch-vod-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 = { "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/twitch-vod-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 '{
  "video_url": "https://www.twitch.tv/riotgames/clip/GoodAlertBurritoTheTarFu"
}' |
apify call agentx/twitch-vod-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rvDjqbn8PL97q85eU/builds/0nwE2s3NEFVGabWYg/openapi.json