# Kick Channel Scraper - Latest VODs & Clips (`hgservices/kick-channel-scraper`) Actor

Scrape the latest VODs (past broadcasts) and clips of any Kick.com channel by username or URL. Get title, description, thumbnail, duration, views, upload date and stream URL for each video.  No login needed.

- **URL**: https://apify.com/hgservices/kick-channel-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped videos

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Kick Channel Scraper** gets the **latest VODs (past broadcasts) and clips** of any [Kick.com](https://kick.com) channel. Enter a streamer's username or channel URL, and get **one row per video** with the title, description, thumbnail, duration, view count, upload date, clip creator and stream URL.

Scrape many Kick channels in one run. Export the data as JSON, CSV, Excel or HTML, read it from the API, or let an AI assistant such as Claude or ChatGPT run the scraper for you.

**No Kick account, no login, no Kick API key and no coding needed.**

### What does Kick Channel Scraper do?

Kick Channel Scraper is a **Kick VOD and clip scraper**. It finds the newest videos of each channel that you give it, and it collects public data about each video.

- **Latest Kick VODs** — the most recent past broadcasts of each channel, newest first.
- **Latest Kick clips** — the most recent clips of each channel, with the username of the viewer who made each clip.
- **Video metadata** — title, description, duration, view count, upload date and thumbnail of every video.
- **Stream URLs** — an `.m3u8` playlist for every video, which players such as VLC can open.
- **Many channels in one run** — add as many Kick streamers as you need.

The scraper runs on the Apify platform. You get **API access, scheduled runs, integrations with your other tools and run monitoring** without extra setup.

Do you have the URLs of specific videos, or do you want the MP4 files? Use **Kick Video Scraper**. It takes the URLs of single VODs and clips, and it can save each video as a file.

### Why scrape Kick channels?

- **Streamer and creator research** — See what a streamer publishes, how long the streams are and how many views each one gets.
- **Clip monitoring** — Collect the newest clips of a channel every day, and find the clips with the most views.
- **Talent scouting and sponsorships** — Compare the activity and audience of many Kick streamers before you contact them.
- **VOD archives** — Keep a record of a channel's VODs and clips. Kick keeps VODs for about 30 days only.
- **Dashboards and AI analysis** — Send structured Kick video data to a spreadsheet, a database, a BI tool or an AI model.

### How to scrape Kick VODs and clips

1. Click **Try for free** and sign in to Apify. A free account is enough.
2. In **Channels**, add one or more channel usernames (for example `xqc`) or channel URLs (for example `https://kick.com/xqc`).
3. Optional: turn off **Include VODs** or **Include clips**, and set **Max items per channel**.
4. Click **Start**.
5. Open the **Output** tab. View the videos as a table, or download them as JSON, CSV, Excel or HTML.

You can also run the scraper from your own code or from an AI assistant. See **Usage examples** below.

### Input

Set the input on the **Input** tab in Apify Console, or send it as JSON through the API.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `channels` | string\[] | — | **Required.** Kick channel usernames (`xqc`) or channel URLs (`https://kick.com/xqc`) |
| `includeVods` | boolean | `true` | Get the past broadcasts of each channel |
| `includeClips` | boolean | `true` | Get the clips of each channel |
| `maxItemsPerChannel` | integer | `20` | The maximum number of VODs, and separately of clips, for each channel (1 to 200). For example, `20` gives up to 20 VODs plus up to 20 clips |

At least one of `includeVods` and `includeClips` must be `true`.

#### Input examples

**The latest 20 VODs and 20 clips of one channel**

```json
{
    "channels": ["xqc"]
}
```

**The 10 newest clips of two channels**

```json
{
    "channels": ["xqc", "https://kick.com/trainwreckstv"],
    "includeVods": false,
    "maxItemsPerChannel": 10
}
```

**The 5 newest VODs of one channel**

```json
{
    "channels": ["xqc"],
    "includeClips": false,
    "maxItemsPerChannel": 5
}
```

### Output

You get one row for each VOD or clip. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example of a VOD:

```json
{
    "type": "vod",
    "id": "e8885172-7587-4fa8-80a2-ec2f140159ba",
    "title": "🦖LIVE🦖LOCK IN🦖GTA V🦖NOPIXEL V🦖BIG DRAMA🦖MEGA DAY🦖HEIST DAY🦖",
    "url": "https://kick.com/xqc/videos/e8885172-7587-4fa8-80a2-ec2f140159ba",
    "channel": "xqc",
    "clipCreator": null,
    "description": "THE BEST AT ABSOLUTELY EVERYTHING. THE JUICER. LEADER OF THE JUICERS.",
    "thumbnail": "https://images.kick.com/video_thumbnails/DsuAwCgUc9Bh/LyweTclipKhZ/720.webp",
    "streamUrl": "https://stream.kick.com/3c81249a5ce0/ivs/v1/196233775518/DsuAwCgUc9Bh/2026/10/9/18/42/LyweTclipKhZ/media/hls/1080p60/playlist.m3u8",
    "durationSeconds": 8170,
    "viewCount": 30637,
    "uploadDate": "2026-10-09",
    "isLive": false,
    "ext": "mp4",
    "filesizeBytes": null,
    "formatsCount": 5,
    "scrapedAt": "2026-10-10T04:37:32.744874+00:00"
}
```

Example of a clip:

```json
{
    "type": "clip",
    "id": "clip_01M4HMYR6NHDD0Y2DZ0TP92ETH",
    "title": "ASPLDK",
    "url": "https://kick.com/xqc/clips/clip_01M4HMYR6NHDD0Y2DZ0TP92ETH",
    "channel": "xqc",
    "clipCreator": "rizkyk",
    "description": "",
    "thumbnail": "https://clips.kick.com/clips/83/clip_01M4HMYR6NHDD0Y2DZ0TP92ETH/thumbnail.webp",
    "streamUrl": "https://clips.kick.com/clips/83/clip_01M4HMYR6NHDD0Y2DZ0TP92ETH/playlist.m3u8",
    "durationSeconds": 180,
    "viewCount": 19,
    "uploadDate": "2026-10-10",
    "isLive": false,
    "ext": "mp4",
    "filesizeBytes": null,
    "formatsCount": 1,
    "scrapedAt": "2026-10-10T04:37:35.891487+00:00"
}
```

#### Kick data fields

| Field | Description |
|-------|-------------|
| `type` | `vod` or `clip` |
| `id` | The Kick ID of the video |
| `title` | The video title |
| `url` | The video page on Kick.com |
| `channel` | The channel username |
| `clipCreator` | The username of the viewer who made the clip (`null` for VODs) |
| `description` | The video description (up to 2,000 characters) |
| `thumbnail` | The thumbnail image URL |
| `streamUrl` | The `.m3u8` stream playlist of the video in the best quality |
| `durationSeconds` | The length of the video in seconds |
| `viewCount` | The number of views when the video was scraped |
| `uploadDate` | The upload date (YYYY-MM-DD) |
| `isLive` | `true` when the stream was live when it was scraped |
| `ext` | The file type of the video |
| `filesizeBytes` | The approximate size of the best quality, when Kick gives it |
| `formatsCount` | The number of qualities that Kick has for the video |
| `scrapedAt` | When the row was scraped (UTC) |

### Usage examples

Run Kick Channel Scraper from Apify Console, from the Apify API, or from an AI assistant. All examples below get the same kind of data.

#### Apify Console (no code)

1. Open the scraper and go to the **Input** tab.
2. Add `xqc` in **Channels**.
3. Set **Max items per channel** to `10`.
4. Click **Start**, and open the **Output** tab when the run finishes.

To run the scraper automatically, open **Schedules** in Apify Console and create a schedule, for example every day at 08:00.

#### Apify API (HTTP)

Get your API token in Apify Console under **Settings → API & Integrations**. Replace `<YOUR_API_TOKEN>` in the examples below.

Run the scraper and get the videos in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~kick-channel-scraper/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "channels": ["xqc"], "maxItemsPerChannel": 10 }'
```

Change `format=json` to `format=csv` or `format=xlsx` to get a spreadsheet.

This call waits for the run to finish, for a maximum of 5 minutes. For runs with many channels, start the run without waiting, and read the dataset when the run finishes:

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~kick-channel-scraper/runs" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "channels": ["xqc", "trainwreckstv", "adinross"], "maxItemsPerChannel": 50 }'
```

The response gives `data.defaultDatasetId`. Get the videos from `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json`.

#### JavaScript / Node.js client

Install the client with `npm install apify-client`.

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('hgservices/kick-channel-scraper').call({
    channels: ['xqc', 'trainwreckstv'],
    includeVods: false,
    maxItemsPerChannel: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const video of items) {
    console.log(video.channel, video.title, video.viewCount, video.url);
}
```

#### Python client

Install the client with `pip install apify-client` (version 3.0 or later).

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("hgservices/kick-channel-scraper").call(run_input={
    "channels": ["xqc"],
    "includeClips": False,
    "maxItemsPerChannel": 5,
})
if run is None:
    raise RuntimeError("The run was not found.")

for video in client.dataset(run.default_dataset_id).iterate_items():
    print(video["uploadDate"], video["durationSeconds"], video["title"])
```

#### AI assistants: Claude, ChatGPT and other MCP clients

Kick Channel Scraper works as a tool for AI assistants through the [Apify MCP server](https://mcp.apify.com/). Your assistant finds the scraper, reads its input options, runs it and uses the videos in its answer.

**Claude (claude.ai or Claude Desktop)** — Go to **Settings → Connectors** and add a custom connector. Enter `https://mcp.apify.com` as the URL. Sign in to Apify when Claude asks.

**Claude Code** — Run this command:

```bash
claude mcp add --transport http apify https://mcp.apify.com
```

**ChatGPT** — Turn on **Developer mode** in ChatGPT. Then go to **Settings → Apps & Connectors → Create**. Enter `https://mcp.apify.com` as the **MCP Server URL**, select **OAuth** and sign in to Apify. In a new chat, click **+**, select **More**, and add the Apify connector.

**Cursor, VS Code and other MCP clients** — Add `https://mcp.apify.com` as a remote MCP server.

To give the assistant only this scraper, use `https://mcp.apify.com?tools=hgservices/kick-channel-scraper` as the server URL.

Then ask in plain language:

> Use the Kick Channel Scraper to list the 10 newest clips of xqc, sorted by views.

> How long were the last 5 streams of trainwreckstv, and how many views did each one get?

> Which clips of my Kick channel "mychannel" got more than 1,000 views this week?

For the best results, give the channel names and a small item limit. This keeps the run short.

### Integrations

Connect Kick Channel Scraper to the tools you already use with [Apify integrations](https://apify.com/integrations): **Google Sheets, Google Drive, Slack, Zapier, Make, n8n, Airbyte** and more. Use **webhooks** to call your own endpoint when a run finishes.

For example, schedule a daily run and send the newest clips of your favorite streamers to a Google Sheet or a Slack channel.

### Tips and limits

- **Run time.** The scraper gets about one video per second. One channel with the default limits (20 VODs and 20 clips) takes about one minute.
- **Get only what you need.** Turn off **Include VODs** or **Include clips**, and lower **Max items per channel**, to make runs shorter.
- **VOD history.** Kick keeps VODs for about 30 days. A channel can give fewer VODs than **Max items per channel**.
- **Live streams.** A stream that is live now has no VOD yet, so the scraper skips it. Run the scraper again after the stream ends.
- **Channel names.** Use the username from the channel URL (letters, digits, `_` and `-`), or paste the channel URL. The scraper skips names that are not valid and URLs that are not on Kick, and writes a warning in the log.

### FAQ

**Do I need a Kick account or a Kick API key?**
No. You need only an Apify account. The scraper reads public videos that every visitor can see.

**Can I download the Kick videos as MP4 files?**
Not with this scraper. It collects the data and the stream URL of each video. Open `streamUrl` in a player such as VLC to watch a video. To save videos as MP4 files, give the video URLs from this scraper to **Kick Video Scraper**.

**Can I scrape old Kick VODs?**
Only the VODs that are still on Kick. Kick keeps VODs for about 30 days. Schedule a daily run to keep your own archive.

**Why did my channel give no videos?**
Check that the channel exists and has VODs or clips. If the channel has videos, run the scraper again a few minutes later.

**Can I get the chat of a Kick VOD?**
Not with this scraper. Use **Kick Chat Replay Scraper** to get the chat messages of a VOD or clip.

**Is it legal to scrape Kick?**
The scraper collects only public data and never signs in. You are responsible for how you use the data, and for compliance with the Kick Terms of Service, copyright law and data protection law such as GDPR. Use only the content that you have the right to use.

### Support

Did you find a bug, or do you need a field that is not here? Open an issue on the **Issues** tab. Custom solutions are available on request.

This scraper is not affiliated with or endorsed by Kick.com.

# Actor input Schema

## `channels` (type: `array`):

Kick channel usernames (for example, xqc) or channel URLs (for example, https://kick.com/xqc), one per line.

## `includeVods` (type: `boolean`):

Process past broadcasts (VODs) discovered on channels.

## `includeClips` (type: `boolean`):

Process clips discovered on channels.

## `maxItemsPerChannel` (type: `integer`):

Maximum number of VODs and, separately, of clips to process per channel (most recent first). For example, 20 gives up to 20 VODs plus up to 20 clips.

## Actor input object example

```json
{
  "channels": [
    "xqc"
  ],
  "includeVods": true,
  "includeClips": true,
  "maxItemsPerChannel": 20
}
```

# Actor output Schema

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

One row per VOD (past broadcast) or clip, with title, channel, stream URL, duration, views and upload date.

# 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 = {
    "channels": [
        "xqc"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/kick-channel-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 = { "channels": ["xqc"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/kick-channel-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channels": [
    "xqc"
  ]
}' |
apify call hgservices/kick-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/kick-channel-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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