# Kick Clip Downloader (`agentx/kick-clip-downloader`) Actor

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

- **URL**: https://apify.com/agentx/kick-clip-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Agents, Developer tools
- **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

Kick Video Downloader converts one public Kick recording or clip into a reviewable Dataset item and can save its available media to Apify storage.

- Handles a known VOD or Clip link as one auditable job.
- Lets metadata inspection finish without the cost and delay of media transfer.
- Normalizes source details into a thumbnail-led, 39-field record.
- Exposes neither comments nor live chat as an input-controlled feature.

**[Set up a smallest run](https://apify.com/agentx/kick-video-downloader)**

**[Explore Apify REST endpoints](https://apify.com/agentx/kick-video-downloader/api)**

### Why Choose This API

Kick separates channels, ongoing broadcasts, past broadcasts, and clips. This Actor provides a small deterministic surface for the two replayable media types: a known VOD or a known Clip. Available title, creator, artwork, timestamps, duration, engagement values, dimensions, and provenance are translated into the AgentX video record.

That narrow promise matters operationally. A channel crawler or live recorder has different retry, completion, and storage behavior. Here, one page should resolve to one media item. The Actor does not enumerate a creator’s archive, follow a live channel, capture chat, discover clips, or authenticate into protected content.

Use metadata as the acceptance gate. If identity is correct, a quality setting can request a file. `high`, `medium`, and `low` are selection preferences; the rendition list supplied by Kick remains authoritative.

### Quick Start Guide

The request shape below contains non-production placeholders:

```json
{
  "video_url": "https://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e",
  "video_quality": "metadata"
}
```

Replace both `example` segments with a current, publicly playable VOD path that you are allowed to process, or provide a valid public Kick Clip URL. Before running, test the exact address in a private browser and ensure it identifies media rather than a general channel.

First compare returned `id`, `platform`, `title`, `author`, `duration`, and `thumbnail` with the page. A creator home, live-only channel, category, search page, missing VOD, or deleted Clip should not be counted as a successful regression. Add file storage only after this metadata check passes.

### Input Parameters

| Property | JSON type | Required | Contract |
|---|---|---:|---|
| `video_url` | string | Yes | One public Kick VOD or Clip URL. |
| `video_quality` | string | No | One of `metadata`, `low`, `medium`, or `high`; omitted means metadata processing. |

The URL placeholder appears as both the required field’s prefill and example. The optional quality selector has no default-like UI value and no example, preventing an optional download choice from being silently imposed.

The input object rejects extra keys. It provides no channel enumeration, query, cursor, date range, cookie, account, country, live-chat, comment, or bulk URL field.

### Output Data Schema

The overview orders the thumbnail first, followed by the remaining normalized properties:

| Record segment | Available keys |
|---|---|
| Source media | `thumbnail`, `id`, `platform`, `title`, `description`, `duration`, `published_at` |
| Kick creator | `author`, `author_id`, `author_url` |
| Discovery and counters | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Rendition facts | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Run provenance | `comments`, `processed_at`, `processor` |

:

```json
{
  "id": "example",
  "platform": "kick:vod",
  "title": "Illustrative Kick VOD",
  "author": "example",
  "thumbnail": "https://example.com/kick-vod-thumbnail.jpg",
  "comments": [],
  "video": ""
}
```

These are explanatory values, not scraped facts. General-purpose keys may be null when Kick does not publish them. Metadata processing leaves `video` blank. The `comments` array is reserved for structural compatibility and must not be interpreted as chat output.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

Since it is not present in the Store, the following HTTP request documents the future route rather than proving current availability:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~kick-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e","video_quality":"metadata"}'
```

An MCP client can describe the identical input after launch:

```json
{
  "mcpServers": {
    "kick-replay": {
      "url": "https://mcp.apify.com?tools=agentx/kick-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e",
    "video_quality": "metadata"
  }
}
```

Treat tokens as secrets and consult the [Apify MCP integration guide](https://docs.apify.com/integrations/mcp) for the supported authentication pattern.

### Pricing & Cost Calculator

Only repository declarations are available before Store publication:

| Charge event | Declared unit | Local USD |
|---|---|---:|
| `actor_usage` | Metered run resources, proxy traffic, and storage | $0.00001 |
| `metadata` | One result produced without storing media | $0.09 |
| `download` | One result produced with a stored video | $0.20 |

Using this table, one metadata result starts at $0.09 plus metered usage, and one result with media starts at $0.20 plus metered usage.

### Use Cases & Applications

Authorized creators can register individual replays in a content inventory. Analysts can cite a VOD with its creator, timing, and artwork. Editors can submit a permitted Clip to review or clipping workflows. AI pipelines can forward an allowed stored video to transcription or classification without changing this Actor’s extraction scope.

To measure change, rerun the exact item and compare dated Dataset rows in a separate system. The Actor does not subscribe to channels or alert on new VODs.

### Limits & Troubleshooting

Kick media can disappear, become restricted, move behind an account flow, expose only limited renditions, or change delivery APIs. Regional access, rate limiting, network behavior, and extractor updates may also affect completion. The public schema offers no credential or geography override.

For an empty result, verify the full VOD or Clip address in a private window and ensure playback is public. Return to metadata mode. If metadata works but `video` is absent in a download mode, review the selected quality, run log, and key-value store.

Before release, exercise a current public VOD, a current public Clip, a channel page expected to be outside contract, a removed item, and an authorized download. Preserve the extractor key, source ID, requested mode, terminal status, and storage evidence.

### FAQ

#### Does it archive every VOD from a Kick creator?

No. Each run receives one already-known media URL.

#### Can I use a live Kick channel URL?

Live operation is not promised by this VOD-and-Clip Store contract. Use the related live workflow.

#### Will it return chat or comments?

No public control requests either dataset, and the reserved array is normally empty.

#### Are protected broadcasts accessible?

No login or cookie input is available.

#### Is high always the same resolution?

No. It selects from renditions actually offered for that item.

#### What does a null metric indicate?

It means the source did not provide the value, not that the metric was measured as zero.

#### Is multi-URL input supported?

No. An orchestrator can start separate runs when multiple items are authorized.

#### Which Kick address format should I submit?

Use the channel-scoped `kick.com/<channel>/videos/<uuid>` form. The UUID is the stable identifier worth storing for deduplication, because the channel segment can change if a creator renames their account. A live channel root has no fixed media target and is outside this single-item contract.

### Legal & Responsible Use

Process Kick recordings and clips only with appropriate access and retention rights. The caller is accountable for platform terms, creator rights, copyright, privacy, local regulations, and deletion policy.

### Related Tools

- [Live Stream Transcript](https://apify.com/agentx/live-stream-transcript) is the better fit for authorized live speech.
- [Video Transcript](https://apify.com/agentx/video-transcript) converts permitted recordings to text.
- [Video Captions Downloader](https://apify.com/agentx/video-captions-downloader) collects available caption tracks.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) covers multiple supported media hosts.

### Support & Community

Store 404 means Actor ID, reviews, Issues, usage totals, and an official public run remain unavailable for verification.

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

When the Actor is live, attach the stable ID, redacted media URL, submitted input, and run ID to any support report.

**[Set up a smallest run](https://apify.com/agentx/kick-video-downloader)**

**[Explore Apify REST endpoints](https://apify.com/agentx/kick-video-downloader/api)**

# Actor input Schema

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

Publicly accessible Kick 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://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e"
}
```

# 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://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/kick-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 = { "video_url": "https://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/kick-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 '{
  "video_url": "https://kick.com/eslcs/videos/37af8853-e784-4a57-a51f-6cefe328903e"
}' |
apify call agentx/kick-clip-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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