# Kick Scraper (`solidcode/kick-scraper`) Actor

\[💰 $2.5 / 1K] Scrape Kick.com channels, live streams, videos, clips, and top-channel rankings. Get profiles, followers, viewer counts, stream titles, categories, social links, and more — for any channel or category.

- **URL**: https://apify.com/solidcode/kick-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Social media, Videos, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

## Kick Scraper

Pull structured data from Kick.com at scale — full streamer profiles, the currently-live directory, past broadcasts and clips with view counts, and the platform's top-channel rankings, all in clean rows you can sort and filter. Four scrape modes share one tidy output schema, so a follower count, a live viewer number, and a clip's view total all come back ready for analysis. Built for talent scouts, sponsorship researchers, esports analysts, and stream-analytics builders who need fresh Kick data without babysitting a browser or copy-pasting numbers off the site.

### Why This Scraper?

- **4 scrape modes in one actor** — Channel Details, Live Streams, Channel Videos, and Top Channels, each selected from a single dropdown. No separate tools, no juggling.
- **Full streamer profiles** — username, bio, follower count, verified and affiliate flags, profile and banner images, subscriber badges, and live status in a single row.
- **Up to 6 social links per channel** — Twitter, Instagram, YouTube, Discord, TikTok, and Facebook handles, expanded into ready-to-click full URLs (not bare handles).
- **VODs and clips with engagement metrics** — past broadcasts carry view counts and duration; clips add likes, the original clipper's name, and unbounded pagination sorted by most-viewed or most-recent.
- **Live-stream directory with real filters** — pull up to ~100 currently-live streams, narrow to a single category, set a minimum-viewer floor, and order by viewers or by most recently started.
- **Rank-ordered top channels** — the curated featured ranking comes back numbered 1, 2, 3…, each enriched with live viewer counts, category, and stream title.
- **Flexible channel input** — paste a bare username (`xqc`), a short link (`kick.com/xqc`), or a full `https://kick.com/...` URL; all three resolve to the same channel.
- **Normalized, consistent fields** — durations always in seconds (VOD milliseconds and clip seconds reconciled for you), viewer counts as numbers, and timestamps in ISO format across every record type.

### Use Cases

**Influencer & Talent Discovery**
- Find live streamers in a category and rank them by current viewers
- Build shortlists of verified or affiliate channels with follower thresholds
- Pull contact and social-handle lists straight from channel profiles
- Spot fast-rising channels by tracking follower counts over time

**Sponsorship & Brand Research**
- Match brands to streamers by category, audience size, and content
- Capture every social link a channel publishes for outreach
- Measure live reach by reading current viewer counts across top channels
- Vet a creator's recent broadcasts and clips before signing a deal

**Stream & Audience Analytics**
- Snapshot the live directory on a schedule to chart viewership trends
- Compare viewer counts across categories like Just Chatting, Slots, or IRL
- Track how long streams run using start-time and duration data
- Benchmark a channel's VOD and clip view counts against peers

**Competitive & Market Research**
- Monitor which categories dominate the featured ranking
- Watch competitor channels' live status, titles, and categories
- Map the mature-content landscape using the per-stream maturity flag
- Track top-channel turnover week over week

**Content Aggregation**
- Collect a channel's most-viewed clips for a highlight reel
- Feed past-broadcast metadata into a content calendar
- Surface trending live streams for a discovery feed or newsletter

### Getting Started

#### Scrape a Channel Profile

The simplest run — full details for one or more channels:

```json
{
    "mode": "channel_details",
    "channelNames": ["xqc", "kick.com/trainwreckstv"]
}
````

#### Browse the Live Directory

Pull the busiest streams in a category, skipping quiet ones:

```json
{
    "mode": "live_streams",
    "category": "just-chatting",
    "minViewers": 500,
    "sortBy": "viewers",
    "maxResults": 100
}
```

#### Collect a Channel's Clips

Grab a channel's most-viewed clips with engagement data:

```json
{
    "mode": "channel_videos",
    "channelNames": ["xqc"],
    "videoType": "clips",
    "sortBy": "viewers",
    "maxResults": 200
}
```

#### Rank the Top Live Channels

```json
{
    "mode": "top_channels",
    "sortBy": "viewers"
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | select | `channel_details` | What to collect: **Channel Details** (full profiles), **Live Streams** (live right now), **Channel Videos** (past broadcasts or clips), or **Top Channels** (most-watched featured channels). |
| `channelNames` | string\[] | `["xqc"]` | Channel names or links, one per line — a bare name (`xqc`), short link (`kick.com/xqc`), or full URL. Used by Channel Details and Channel Videos. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `""` | Return only streams in this category. Use the slug as it appears in the Kick URL — e.g. `just-chatting`, `slots`, `fortnite`. Applies to Live Streams and Top Channels. Leave empty for all categories. |
| `videoType` | select | `videos` | For Channel Videos: collect full **past broadcasts (VODs)** or short **clips**. |
| `sortBy` | select | `viewers` | Ordering — **most viewers** first or **most recent**. Applies to Live Streams, Top Channels, and Channel Videos clips (clips: most-viewed vs. most recently created). Past broadcasts (VODs) always come back newest-first. |
| `minViewers` | integer | `0` | Drop streams with fewer current viewers than this. Leave at 0 to include every stream. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Most rows to return this run (1–1000). Some modes have natural ceilings: Live Streams returns up to ~100, Top Channels ~14, and VODs up to the 24 most recent per channel. Clips and Channel Details honor this limit fully. |

### Output

Every row carries a `recordType` field (`channel`, `stream`, `video`, or `topChannel`) and a `scrapedAt` ISO timestamp, so mixed datasets stay easy to split. Each mode produces one record type.

#### Channel (`channel_details`)

```json
{
    "recordType": "channel",
    "channelName": "xqc",
    "channelUrl": "https://kick.com/xqc",
    "displayName": "xQc",
    "bio": "THE BEST STREAMER IN THE WORLD",
    "avatarUrl": "https://files.kick.com/images/user/xqc/profile.webp",
    "bannerUrl": "https://files.kick.com/images/user/xqc/banner.webp",
    "followersCount": 1248300,
    "isLive": true,
    "currentViewers": 41200,
    "currentCategory": "Just Chatting",
    "currentStreamTitle": "REACTING TO EVERYTHING",
    "startedAt": "2026-06-19T13:02:00Z",
    "verified": true,
    "isAffiliate": true,
    "isBanned": false,
    "hasSubscriptions": true,
    "subscriberBadges": [{ "months": 1, "imageUrl": "https://files.kick.com/badges/1.png" }],
    "socialLinks": {
        "twitter": "https://twitter.com/xqc",
        "instagram": "https://www.instagram.com/xqc",
        "youtube": "https://www.youtube.com/xqc",
        "discord": null,
        "tiktok": null,
        "facebook": null
    },
    "createdAt": "2022-09-30T18:14:00Z",
    "scrapedAt": "2026-06-19T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `channelName` | string | Channel slug (the part after kick.com/) |
| `channelUrl` | string | Full channel URL |
| `displayName` | string | Streamer's display name |
| `bio` | string | Channel bio / about text |
| `avatarUrl` | string | Profile picture URL |
| `bannerUrl` | string | Channel banner image URL |
| `followersCount` | number | Total follower count |
| `isLive` | boolean | Whether the channel is streaming right now |
| `currentViewers` | number | Live viewer count (null when offline) |
| `currentCategory` | string | Category being streamed (null when offline) |
| `currentStreamTitle` | string | Current stream title (null when offline) |
| `startedAt` | string | Stream start time (null when offline) |
| `verified` | boolean | Verified-channel flag |
| `isAffiliate` | boolean | Affiliate-program flag |
| `isBanned` | boolean | Whether the channel is currently banned on Kick |
| `hasSubscriptions` | boolean | Whether subscriptions are enabled |
| `subscriberBadges` | object\[] | Subscriber-tier badges (months + image URL) |
| `socialLinks` | object | Full URLs for Twitter, Instagram, YouTube, Discord, TikTok, Facebook |
| `createdAt` | string | Channel creation date |

#### Live Stream (`live_streams`)

```json
{
    "recordType": "stream",
    "channelName": "trainwreckstv",
    "channelUrl": "https://kick.com/trainwreckstv",
    "displayName": "Trainwreckstv",
    "viewers": 18750,
    "title": "SLOTS & CHILL",
    "category": "Slots",
    "language": "English",
    "startedAt": "2026-06-19T12:40:00Z",
    "thumbnailUrl": "https://images.kick.com/video_thumbnails/trainwreckstv/720.webp",
    "isMature": true,
    "tags": ["gambling", "slots"],
    "scrapedAt": "2026-06-19T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `channelName` | string | Channel slug |
| `channelUrl` | string | Full channel URL |
| `displayName` | string | Streamer's display name |
| `viewers` | number | Current viewer count |
| `title` | string | Stream title |
| `category` | string | Stream category name |
| `language` | string | Stream language |
| `startedAt` | string | Stream start time |
| `thumbnailUrl` | string | Live thumbnail image URL |
| `isMature` | boolean | Mature-content flag |
| `tags` | string\[] | Stream tags |

#### Video & Clip (`channel_videos`)

```json
{
    "recordType": "video",
    "channelName": "xqc",
    "channelUrl": "https://kick.com/xqc",
    "type": "clip",
    "clipId": "clip_01HXYZ",
    "title": "Insane clutch moment",
    "duration": 42,
    "views": 215000,
    "likes": 8400,
    "category": "Counter-Strike 2",
    "createdAt": "2026-06-10T19:22:00Z",
    "thumbnailUrl": "https://clips.kick.com/clip_01HXYZ/thumb.webp",
    "videoUrl": "https://kick.com/xqc/clips/clip_01HXYZ",
    "creator": "clipmaster99",
    "isMature": false,
    "scrapedAt": "2026-06-19T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `channelName` | string | Channel slug |
| `channelUrl` | string | Full channel URL |
| `type` | string | `video` (past broadcast) or `clip` |
| `clipId` | string | Unique video or clip identifier |
| `title` | string | Video or clip title |
| `duration` | number | Length in seconds (normalized for both VODs and clips) |
| `views` | number | View count |
| `likes` | number | Like count (clips only; null on VODs) |
| `category` | string | Category the content belongs to |
| `createdAt` | string | Publication date |
| `thumbnailUrl` | string | Thumbnail image URL |
| `videoUrl` | string | Direct watch URL |
| `creator` | string | Username of the clip's creator (clips only) |
| `isMature` | boolean | Mature-content flag |

#### Top Channel (`top_channels`)

```json
{
    "recordType": "topChannel",
    "rank": 1,
    "channelName": "xqc",
    "channelUrl": "https://kick.com/xqc",
    "displayName": "xQc",
    "avatarUrl": "https://files.kick.com/images/user/xqc/profile.webp",
    "currentViewers": 41200,
    "currentStreamTitle": "REACTING TO EVERYTHING",
    "category": "Just Chatting",
    "startedAt": "2026-06-19T13:02:00Z",
    "bio": "THE BEST STREAMER IN THE WORLD",
    "isAffiliate": true,
    "hasSubscriptions": true,
    "socialLinks": { "twitter": "https://twitter.com/xqc" },
    "scrapedAt": "2026-06-19T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `rank` | number | Position in the featured ranking (1 = top) |
| `channelName` | string | Channel slug |
| `channelUrl` | string | Full channel URL |
| `displayName` | string | Streamer's display name |
| `avatarUrl` | string | Profile picture URL |
| `currentViewers` | number | Live viewer count |
| `currentStreamTitle` | string | Current stream title |
| `category` | string | Category being streamed |
| `startedAt` | string | Stream start time |
| `bio` | string | Channel bio (enriched per channel) |
| `isAffiliate` | boolean | Affiliate-program flag (enriched) |
| `hasSubscriptions` | boolean | Subscriptions enabled (enriched) |
| `socialLinks` | object | Full social URLs (enriched) |

### Tips for Best Results

- **Get category slugs from the Kick URL.** Open a category page on Kick and copy the slug from the address bar — `kick.com/browse/categories/just-chatting` means your `category` value is `just-chatting`. The visible category name won't work.
- **Clips is the only unbounded mode.** Past broadcasts cap at the 24 most recent per channel, Live Streams at ~100, and Top Channels at ~14. If you need deep history for a channel, use `videoType: "clips"` and raise `maxResults`.
- **Use `minViewers` to focus on active streams.** Setting a floor like 500 trims the long tail of tiny streams so you only keep channels with real reach — ideal for sponsorship shortlists.
- **Mix input formats freely.** `channelNames` accepts bare names, short links, and full URLs in the same run, so you can paste a list straight from wherever you collected it.
- **Snapshot live data on a schedule.** Live viewer counts and the directory change minute to minute — run Live Streams or Top Channels on a recurring schedule to build a time series.
- **Split mixed datasets by `recordType`.** When you run several modes into one dataset, filter on `recordType` (`channel`, `stream`, `video`, `topChannel`) to separate them cleanly.

### Pricing

**From $2.50 per 1,000 results** — competitively priced for Kick data, with deeper discounts as your subscription tier grows. The table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is any row in the output dataset — a channel, stream, video, clip, or top-channel entry. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is intended for legitimate research, analytics, talent discovery, and brand work using publicly available Kick.com data. You are responsible for complying with applicable laws and Kick's Terms of Service. Do not use collected data for spam, harassment, or any unlawful purpose, and handle any personal data (such as social handles) in line with relevant privacy regulations. </content> </invoke>

# Actor input Schema

## `mode` (type: `string`):

Choose what kind of data to collect. Channel Details and Channel Videos use the channels you list below. Live Streams and Top Channels browse Kick for you. Note: Kick's directories have natural limits — Live Streams returns up to ~100 currently-live streams, Top Channels returns the ~14 most-watched featured channels, and past broadcasts (VODs) are limited to the 24 most recent per channel. Clips have no such limit.

## `channelNames` (type: `array`):

Channel names or links — one per line. You can paste just the name (xqc), a short link (kick.com/xqc), or a full URL (https://kick.com/xqc). Used by the Channel Details and Channel Videos modes.

## `category` (type: `string`):

Only return streams in this category. Use the category's slug as it appears in the Kick URL, for example just-chatting, slots, or fortnite. Leave empty for all categories. Applies to Live Streams and Top Channels.

## `videoType` (type: `string`):

For Channel Videos mode: collect full past broadcasts (VODs) or short clips.

## `sortBy` (type: `string`):

Order for Live Streams, Top Channels, and Channel Videos clips: most viewers first (for clips, most-viewed), or most recent (for clips, most recently created). Note: Channel Videos past broadcasts (VODs) always come back newest-first as Kick returns them.

## `minViewers` (type: `integer`):

Skip streams with fewer current viewers than this. Leave at 0 to include every stream.

## `maxResults` (type: `integer`):

The most rows to return for this run. Keep this reasonable to control your cost. Some modes have fixed ceilings set by Kick: Live Streams returns at most ~100 results (the live directory is a curated feed with no deeper paging), Top Channels returns ~14, and past broadcasts (VODs) are capped at the 24 most recent per channel — a higher value can't exceed these. Clips and Channel Details honour this limit fully.

## Actor input object example

```json
{
  "mode": "channel_details",
  "channelNames": [
    "xqc"
  ],
  "videoType": "videos",
  "sortBy": "viewers",
  "minViewers": 0,
  "maxResults": 50
}
```

# Actor output Schema

## `channels` (type: `string`):

Channel profiles — display name, bio, followers, live status, current category, verified/affiliate flags, and social links.

## `streams` (type: `string`):

Currently-live streams — streamer, viewers, title, category, language, and start time.

## `videos` (type: `string`):

Past broadcasts (VODs) and clips — title, duration, views, likes, category, and links.

## `topChannels` (type: `string`):

Ranked most-watched live channels — rank, channel, current stream, viewers, and status flags.

# 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 = {
    "mode": "channel_details",
    "channelNames": [
        "xqc"
    ],
    "category": "",
    "videoType": "videos",
    "sortBy": "viewers",
    "minViewers": 0,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/kick-scraper").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 = {
    "mode": "channel_details",
    "channelNames": ["xqc"],
    "category": "",
    "videoType": "videos",
    "sortBy": "viewers",
    "minViewers": 0,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/kick-scraper").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 '{
  "mode": "channel_details",
  "channelNames": [
    "xqc"
  ],
  "category": "",
  "videoType": "videos",
  "sortBy": "viewers",
  "minViewers": 0,
  "maxResults": 50
}' |
apify call solidcode/kick-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kick Scraper",
        "description": "[💰 $2.5 / 1K] Scrape Kick.com channels, live streams, videos, clips, and top-channel rankings. Get profiles, followers, viewer counts, stream titles, categories, social links, and more — for any channel or category.",
        "version": "1.0",
        "x-build-id": "FRhSpdoY92I6XiDkb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~kick-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-kick-scraper",
                "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/solidcode~kick-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-kick-scraper",
                "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/solidcode~kick-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-kick-scraper",
                "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",
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "channel_details",
                            "live_streams",
                            "channel_videos",
                            "top_channels"
                        ],
                        "type": "string",
                        "description": "Choose what kind of data to collect. Channel Details and Channel Videos use the channels you list below. Live Streams and Top Channels browse Kick for you. Note: Kick's directories have natural limits — Live Streams returns up to ~100 currently-live streams, Top Channels returns the ~14 most-watched featured channels, and past broadcasts (VODs) are limited to the 24 most recent per channel. Clips have no such limit.",
                        "default": "channel_details"
                    },
                    "channelNames": {
                        "title": "Channels",
                        "type": "array",
                        "description": "Channel names or links — one per line. You can paste just the name (xqc), a short link (kick.com/xqc), or a full URL (https://kick.com/xqc). Used by the Channel Details and Channel Videos modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Only return streams in this category. Use the category's slug as it appears in the Kick URL, for example just-chatting, slots, or fortnite. Leave empty for all categories. Applies to Live Streams and Top Channels."
                    },
                    "videoType": {
                        "title": "Video type",
                        "enum": [
                            "videos",
                            "clips"
                        ],
                        "type": "string",
                        "description": "For Channel Videos mode: collect full past broadcasts (VODs) or short clips.",
                        "default": "videos"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "viewers",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Order for Live Streams, Top Channels, and Channel Videos clips: most viewers first (for clips, most-viewed), or most recent (for clips, most recently created). Note: Channel Videos past broadcasts (VODs) always come back newest-first as Kick returns them.",
                        "default": "viewers"
                    },
                    "minViewers": {
                        "title": "Minimum viewers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip streams with fewer current viewers than this. Leave at 0 to include every stream.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "The most rows to return for this run. Keep this reasonable to control your cost. Some modes have fixed ceilings set by Kick: Live Streams returns at most ~100 results (the live directory is a curated feed with no deeper paging), Top Channels returns ~14, and past broadcasts (VODs) are capped at the 24 most recent per channel — a higher value can't exceed these. Clips and Channel Details honour this limit fully.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```