# Kick.com Scraper: Streams, Clips, VODs & Profiles (`arabiainsights/kick-research-scraper`) Actor

Collect public Kick profiles, live stream metrics, clips and recent VODs. Find channels by game, language or name without a Kick login.

- **URL**: https://apify.com/arabiainsights/kick-research-scraper.md
- **Developed by:** [Arabia Insights](https://apify.com/arabiainsights) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 kick 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/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

Collect public [Kick.com](https://kick.com/) creator and content data in one Apify Actor. Get **channel profiles and follower counts, current livestreams, clips, and completed videos (VODs)**. Find creators you already know, search channel names, or discover live streams by game and language. No Kick login, cookies, or API credentials are required.

Each run creates a snapshot of information available at that time. You can repeat runs with Apify schedules, use the Apify API, and export results as JSON, CSV, or Excel.

### What can you collect?

Choose one or more result types in **What would you like to collect?**. A profile-only run does not also collect that channel's clips or videos.

| Result type | Useful fields |
| --- | --- |
| **Profiles** | Username, channel ID, bio, exact follower count where exposed, verification and live status, social links, panels, recent categories, public chatroom settings |
| **Live streams** | Title, current viewers, language, game/category, start time where known, tags, thumbnail, available playback URL |
| **Clips** | Title, creator and broadcaster, publication time, views, duration, category, thumbnail, source VOD/offset where exposed, available media URL |
| **Videos** | Completed VOD title, views, duration, language, category, start/end time where known, thumbnail, available recording URL |
| **Schedules** | Public events for one UTC month where exposed; this option is experimental |

Every result has a `type`, stable `recordId`, channel, URL, and `observedAt` time. A missing source value is `null`; an observed zero or false stays zero or false. Media URLs are references, often HLS playlists. The Actor does not download video files or verify that a URL will remain playable.

### How to scrape Kick channels

1. Open the Actor's **Input** tab and choose **Known channels / content URLs**, **Find live streams by game or language**, or **Search channel names**.
2. In **What would you like to collect?**, keep only the result types you need. Select **Live streams** alone for current broadcasts or **Profiles** alone for followers and social links.
3. Fill in the matching task section: Kick usernames/URLs, games for live discovery, or channel-name search terms.
4. Optionally choose one or more **Languages**. Leave this empty for all languages. Set the channel and record limits, then click **Start**.
5. Download the **Results** dataset. Open **Channel report** and **Coverage and run summary** in the run output to see why a channel produced fewer records than requested.

For **PUBG livestreams in Arabic**, choose *Find live streams by game or language*, select only *Live streams*, select *Arabic*, and choose *PUBG Mobile*, *PUBG: Battlegrounds*, or both. To include Arabic, English, and Turkish, select all three languages. A result must match one selected game **and** one selected language. Multiple choices within either group match any choice. Optional stream-title phrases such as `ranked` narrow those results further.

For a **profile-only** run, choose *Known channels*, select only *Profiles*, and add usernames such as `3mr` and `xqc`. Leave languages and live-viewer filters empty to include offline channels. For **videos only**, select *Videos* and add channel URLs or usernames. Direct Kick clip and video URLs work with their corresponding selected type.

The channel limit applies to the entire run, across all selected games and languages. Duplicate channel inputs are collected once. An offline channel produces no livestream row; select *Profiles* too if you need an offline-channel row.

### Input examples for the Apify API

Find up to 10 Arabic PUBG livestreams:

```json
{
  "task": "live",
  "include": ["livestream"],
  "categories": ["pubg-mobile", "pubg-battlegrounds"],
  "languages": ["ar"],
  "maxChannels": 10,
  "maxResults": 10
}
```

Collect profiles for three channels:

```json
{
  "task": "channels",
  "include": ["profile"],
  "usernames": ["3mr", "xqc", "adinross"]
}
```

The form provides filters for followers, current viewers, clip/VOD views and dates, clip sorting, media URLs, and bounded run limits. API clients can combine types, for example `"include": ["profile", "livestream"]`. `languages` accepts supported Kick language codes or names; `ar`, `en`, and `tr` are Arabic, English, and Turkish.

### Output example

This shortened, illustrative example shows one livestream row. Actual values change with the live source:

```json
{
  "schemaVersion": "1.0",
  "recordId": "livestream:128394140",
  "type": "livestream",
  "id": "128394140",
  "channelId": "29513073",
  "channelSlug": "examplecreator",
  "url": "https://kick.com/examplecreator",
  "observedAt": "2026-09-23T10:00:00.000Z",
  "title": "Ranked PUBG matches",
  "viewerCount": 1200,
  "language": "ar",
  "category": { "name": "PUBG Mobile", "slug": "pubg-mobile" },
  "media": { "url": "https://example.com/playlist.m3u8", "type": "hls", "available": true, "playbackVerified": false }
}
```

The JSON dataset keeps nested category, social-link, and media objects. CSV or Excel exports work for spreadsheets; JSON preserves the complete structure. **Channel report** accounts for planned channels, including duplicates, offline channels, filters, missing channels, and limits. **Coverage and run summary** explains source-page coverage and partial results. These reports are separate from the results dataset.

### Pricing

Pricing uses Apify pay-per-event billing: **$0.0015 when the Actor starts** and one charge for **each result row** saved in the default dataset. Profiles, livestreams, clips, VODs, and schedule events use the same result price:

| Apify plan | Price per 1,000 results |
| --- | ---: |
| Free | $2.20 |
| Starter | $2.10 |
| Scale | $2.00 |
| Business and higher | $1.90 |

For example, a Free-plan run returning 100 records costs about **$0.2215** in Actor event charges, including one start. Platform usage during the Actor run is included. Check the current prices on the Actor's **Pricing** tab before starting; your Apify plan and spending limit determine the applicable total. Source failures, retries, and summary/report records do not create result-item charges. A run with no results can still incur its start charge, and a resurrected run can incur another start charge. Apify may charge separately for storage access after a run.

For a predictable bill, select only the result types you need and set **Maximum channels to check** and **Maximum total records**. Apify also lets you set a maximum run charge. The Actor stops adding results when that limit would be exceeded.

### Coverage and common questions

#### Can I get every past Kick video or every follower account?

No. Kick's public video listing exposes a recent window; increasing the input limit cannot recover older, private, removed, or expired videos. The Actor returns an available **follower count**, not the list of follower accounts. It does not collect chat messages or build a full chat archive.

#### Why did fewer channels or clips appear than I requested?

Limits are ceilings, not guaranteed counts. A channel may be offline, filtered by language or viewer count, missing, or outside a source listing's available window. The global record limit can be used by earlier channels. Open **Channel report** for each channel's status and **Coverage and run summary** for list/page stop reasons. Search and VOD history can be source-limited even when the run itself succeeds.

#### Can I track changes over time?

Yes. Schedule bounded runs and compare their `observedAt` snapshots in your own workflow. Each fresh run observes the source again; the Actor does not reconstruct past viewer or follower values that were never observed.

#### Are the media URLs downloadable files?

They are source-provided references, sometimes HLS playlists rather than MP4 files. A URL may expire or need source-side access conditions. The Actor returns metadata and available URLs; it does not download media.

The Actor collects information publicly exposed by Kick. Use the data in line with applicable law and Kick's terms. If a source response changes or access is blocked, the run reports the limitation instead of inventing empty results. For help with a run, include its run ID and the relevant Channel report when opening an issue on the Actor page.

# Actor input Schema

## `task` (type: `string`):

Known channels uses only your URLs/usernames. Find live streams uses the games and optional title keywords in Live discovery. Channel name search uses only its search terms. Inputs in other task sections are ignored. Languages and channel filters apply to every task. Combine inputs supports existing saved tasks and advanced mixed sources.

## `include` (type: `array`):

Select one or more options. Profiles include followers, social links, panels and chat settings. Live streams include current viewers, language and category; offline channels return no live row. Clips and videos return metadata and optional media URLs. Schedules are experimental. To get only one type, remove the other selected options.

## `languages` (type: `array`):

Select Arabic, English, Turkish, or any combination. Leave empty for all languages. This filters the CURRENT live stream, including when collecting profiles, clips or videos; offline/unknown-language channels do not match. JSON/API also accepts language codes such as ar/en/tr. Regional codes can be entered explicitly, e.g. en-IN.

## `maxChannels` (type: `integer`):

Maximum distinct channels checked after discovery. Live discovery merges selected games/languages by viewer count. This is a total, not a quota per language or game. Offline changes, follower filters or unavailable data can produce fewer results.

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

Hard cap across all profile, live, clip, VOD and schedule rows.

## `startUrls` (type: `array`):

Paste channel URLs such as https://kick.com/3mr. You can also use /clips, /videos, or direct content URLs. For a direct clip or video, select its data type above. Direct content URLs fetch that item and any selected profile/live data; use a channel URL for full lists. Leave empty when using usernames or discovery.

## `usernames` (type: `array`):

Enter usernames such as 3mr or xqc. Use this instead of URLs, or combine both lists. Leave empty when using only discovery.

## `categories` (type: `array`):

Type PUBG to choose PUBG Mobile, PUBG: Battlegrounds, or both. Choosing the custom entry pubg includes both. You can also paste a Kick category URL, use a suggested game name, or enter a category slug. Leave empty for all games. A stream must match one selected game AND one selected language. Used by Find live streams and Combine inputs.

## `liveKeywords` (type: `array`):

Optional extra filter on current stream titles, ignoring case. Enter separate phrases such as ranked or tournament; any phrase can match. Combine with games and languages to narrow results. Leave empty to include all titles. To find all PUBG streams, select the game instead of requiring PUBG in the title. Used by Find live streams and Combine inputs; scanning stops at your page/request/time limits.

## `searchQueries` (type: `array`):

Find creators by channel name, for example xqc. Multiple terms add their results together. For a game such as PUBG, choose Find live streams and select the game in Live discovery. Kick exposes only a limited channel-search window.

## `maxClipsPerChannel` (type: `integer`):

Used only when Clips is selected. Maximum matching clips per channel; zero skips channel clip lists. Ignored when Collect all available history is on.

## `clipSort` (type: `string`):

Used only for channel clip lists. Choose newest first or most viewed first.

## `clipRange` (type: `string`):

Used only for channel clip lists. Kick-defined day, week, month or all-time window.

## `includeClipDetails` (type: `boolean`):

Retrieve source VOD links/offsets when available. Disabling reduces requests.

## `maxVideosPerChannel` (type: `integer`):

Used only when Videos is selected. Maximum matching completed videos (VODs) per channel; zero skips channel video lists. Kick exposes a recent window, so fewer videos may be available. Ignored when Collect all available history is on.

## `allAvailable` (type: `boolean`):

Remove per-channel clip/VOD caps while retaining total record, page, request and time limits. Does not recover deleted or inaccessible history.

## `createdAfter` (type: `string`):

Inclusive lower timestamp for clips and VODs, e.g. 2026-09-01T00:00:00Z. Unknown creation dates do not match.

## `createdBefore` (type: `string`):

Exclusive upper timestamp for clips and VODs.

## `minViews` (type: `integer`):

Clip/VOD view-count filter; unknown counts do not match.

## `includeMediaUrls` (type: `boolean`):

Return HLS or direct media references where exposed. VOD details may be needed. URLs may expire; files are not downloaded.

## `minFollowers` (type: `integer`):

Channel follower-count filter; unknown counts do not match.

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

Current live-viewer filter; offline/unknown counts do not match.

## `scheduleMonth` (type: `string`):

YYYY-MM; defaults to the current UTC month.

## `maxPagesPerSurface` (type: `integer`):

Stop paginated clip lists after this many pages per channel. In Find live streams, this page budget is shared across all selected game/language feeds, which are visited in rounds. Very narrow title filters may need more pages.

## `maxRequests` (type: `integer`):

Total source HTTP attempts, including retries.

## `maxRunSeconds` (type: `integer`):

Stop new source work after this many seconds; finish saving already collected records.

## `requestDelayMillis` (type: `integer`):

Minimum delay between source requests.

## `maxRetries` (type: `integer`):

Bounded retries for network, rate-limit and temporary source errors.

## `discoverLive` (type: `boolean`):

Legacy API option for Combine inputs. Find live streams enables discovery automatically. When categories are selected, browsing stays within those categories.

## `proxyConfiguration` (type: `object`):

Optional Apify/custom proxy. Disabled by default; proxy charges depend on your configuration.

## Actor input object example

```json
{
  "task": "channels",
  "include": [
    "profile"
  ],
  "languages": [],
  "maxChannels": 25,
  "maxResults": 10000,
  "startUrls": [],
  "usernames": [
    "3mr"
  ],
  "categories": [],
  "liveKeywords": [],
  "searchQueries": [],
  "maxClipsPerChannel": 100,
  "clipSort": "recent",
  "clipRange": "all",
  "includeClipDetails": true,
  "maxVideosPerChannel": 100,
  "allAvailable": false,
  "includeMediaUrls": true,
  "maxPagesPerSurface": 50,
  "maxRequests": 1000,
  "maxRunSeconds": 900,
  "requestDelayMillis": 300,
  "maxRetries": 2,
  "discoverLive": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `channelReport` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "task": "channels",
    "include": [
        "profile"
    ],
    "usernames": [
        "3mr"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arabiainsights/kick-research-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 = {
    "task": "channels",
    "include": ["profile"],
    "usernames": ["3mr"],
}

# Run the Actor and wait for it to finish
run = client.actor("arabiainsights/kick-research-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 '{
  "task": "channels",
  "include": [
    "profile"
  ],
  "usernames": [
    "3mr"
  ]
}' |
apify call arabiainsights/kick-research-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arabiainsights/kick-research-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/RuDsaI8y90hTt1ewG/builds/Q23tg22N59HHe1JHl/openapi.json