# High Quality Twitch Clip Downloader (`apilabs/high-quality-twitch-clip-downloader`) Actor

Download Twitch Clips videos or extract audio without any limits

- **URL**: https://apify.com/apilabs/high-quality-twitch-clip-downloader.md
- **Developed by:** [ApiLabs](https://apify.com/apilabs) (community)
- **Categories:** Social media, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 per success results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## High Quality Twitch Clip Downloader API

### Overview

The Twitch Clip Downloader API provides a powerful and flexible solution for downloading videos at the best available quality from YouTube. With support for multiple formats like MP3 and MP4. This downloader is perfect for developers looking to integrate seamless media downloading capabilities into their applications.

### Features

- **Download Video**: Fetch and store high-quality videos from Twitch Clips.
- **Download Audio**: Extract and save audio tracks in various formats, including MP3.
- **Format Options**: Choose between MP3 and MP4 formats for your downloads.

### Important Notes

1. **Proxy Usage**: If you are using a proxy, please ensure that it is correctly configured and you are using a reliable proxy group. This will help avoid IP blocking by YouTube.

2. **QuickTime Note for Mac Users**: If you are using macOS, the downloaded video may not work properly with QuickTime Player due to codec issues. In such cases, use a different media player like VLC, or convert the file format using a tool like FFmpeg.

3. **Video and Link Storage**: Every time the API runs:
   - The video download link is stored in one dataset.
   - The actual video is stored in another dataset, enabling easy access and management of the media files.

### Input Parameters

The API accepts the following input parameters:

- **url**: The URL of the YouTube video or audio content to download.
- **onlyAudio**: A boolean flag (`true`/`false`) indicating whether to download audio only.
- **useFFmpeg**: A boolean flag (`true`/`false`) to specify if FFmpeg should be used for processing.
- **proxy**: (Optional) The proxy URL to be used for the download.

**Note**: Using a proxy is recommended to avoid being blocked by Twitch. However, it may increase download times. If you experience any issues, consider changing your proxy.


### Output

Upon a successful request, the API stores an item in the dataset the following format:

```json
{
  "download_link": "your_download_link_here",
  "status_code": 200
}
````

### Usage Example Python

The following example shows an full example of usage from running an actor to downloading the video on your device.

```python
import requests
import mimetypes
from apify_client import ApifyClient

## Initialize the ApifyClient with an API token
## (You can generate your own Apify API token for authentication)
apify_client = ApifyClient('your_apify_api_token')

## Define the input for the actor that downloads TikTok videos
actor_input = {
    "audioOnly": False,  ## Set to True if you only want to download audio, False for full video
    "ffmpeg": True,  ## Whether to use ffmpeg for processing
    "proxy": {
        "useApifyProxy": True,  ## Enable the use of Apify Proxy
        "apifyProxyGroups": ["RESIDENTIAL"],  ## Specify the proxy group to use (e.g., residential)
        "apifyProxyCountry": "HR"  ## Set the country code for the proxy (e.g., HR for Croatia)
    },
    "url": "TikTok_url"  ## The TikTok URL to download
}

## Start the actor on Apify and wait for it to finish
## (Replace 'demolitore/my-actor' with the actor you want to use)
actor_call = apify_client.actor('apilabs/high-quality-twitch-clip-downloader').call(run_input=actor_input)

## Retrieve the dataset associated with the TikTok downloader
my_dataset_client = apify_client.dataset('your_username/Twitch-Clip-Downloader')

## Fetch the most recent dataset entry, which contains the download link
l = my_dataset_client.list_items(limit=1, desc=True) #Get the only last element inserted
url = l.items[0]['download_link']  ## Extract the download link from the dataset

## Download the file using the URL extracted from the dataset
response = requests.get(url)
## If the download is successful (status code 200), proceed to save the file
if response.status_code == 200:
    ## Get the Content-Type from the response headers to infer the file extension
    content_type = response.headers.get('Content-Type')

    ## Guess the appropriate file extension based on the Content-Type
    extension = mimetypes.guess_extension(content_type.split(';')[0])

    ## Extract the base filename from the URL and append the correct file extension
    filename = url.split("/")[-1].split("?")[0]
    filename = f"{filename}{extension}"  ## Combine the base filename with the extension

    ## Save the file to the local disk in binary mode
    with open(filename, 'wb') as file:
        file.write(response.content)

    ## Print success message with the saved filename
    print(f"File downloaded successfully as {filename}.")
else:
    ## Print an error message if the download fails
    print(f"Failed to download file. Status code: {response.status_code}")
```

##### Disclaimer

This tool is intended for personal use and educational purposes only. Users are solely responsible for ensuring their use complies with YouTube's Terms of Service, applicable copyright laws, and any other relevant regulations.
Downloading copyrighted content without the rights holder's permission may be illegal in your jurisdiction. The developers of this tool do not condone piracy and accept no liability for misuse.

# Actor input Schema

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

The URL of video you want to get the download.

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

Download only audio in mp3 format - Requires ffmpeg

## `ffmpeg` (type: `boolean`):

Slower but enables better quality, by merging the best video with the best audio

## `proxy` (type: `object`):

Select proxies to be used

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/watch?v=xuP4g7IDgDM"
  ],
  "audioOnly": false,
  "ffmpeg": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AL"
  }
}
```

# 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=xuP4g7IDgDM"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "AL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apilabs/high-quality-twitch-clip-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=xuP4g7IDgDM"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "AL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("apilabs/high-quality-twitch-clip-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=xuP4g7IDgDM"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AL"
  }
}' |
apify call apilabs/high-quality-twitch-clip-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "High Quality Twitch Clip Downloader",
        "description": "Download Twitch Clips videos or extract audio without any limits",
        "version": "0.0",
        "x-build-id": "aTqMeNZ1LgwWLoMzs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apilabs~high-quality-twitch-clip-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apilabs-high-quality-twitch-clip-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/apilabs~high-quality-twitch-clip-downloader/runs": {
            "post": {
                "operationId": "runs-sync-apilabs-high-quality-twitch-clip-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/apilabs~high-quality-twitch-clip-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-apilabs-high-quality-twitch-clip-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "URL of the video",
                        "type": "array",
                        "description": "The URL of video you want to get the download.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "audioOnly": {
                        "title": "Audio Only",
                        "type": "boolean",
                        "description": "Download only audio in mp3 format - Requires ffmpeg",
                        "default": false
                    },
                    "ffmpeg": {
                        "title": "Use ffmpeg - Slower but enables better quality download",
                        "type": "boolean",
                        "description": "Slower but enables better quality, by merging the best video with the best audio",
                        "default": true
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used "
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
