# Kick Data Scraper (`aitooolsmax/kick-data-scraper`) Actor

Discover Kick channels and get clean channel snapshots from search, category browsing, livestream discovery, or direct slugs.

- **URL**: https://apify.com/aitooolsmax/kick-data-scraper.md
- **Developed by:** [AI Tools Max](https://apify.com/aitooolsmax) (community)
- **Categories:** Social media, Videos, Developer tools
- **Features:** Limited permissions
- **Stats:** 106 total users, 4 monthly users, 98.4% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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/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.com Channel Data API & Scraper

Export Kick.com channel and streamer data from usernames, search, categories, or live streams. Get follower counts, live status, viewer counts, social links, profile URLs, and source URLs.

**Outputs channel snapshots only.** Videos and clips are not scraped by this actor; their URLs are included as channel metadata for follow-up workflows.

### Ready-To-Run Examples

These examples are also published on Apify Store:

- [Export Kick.com channel data with an API](https://apify.com/aitooolsmax/kick-data-scraper/examples/kick-channel-data-api)
- [Export Kick.com streamer stats](https://apify.com/aitooolsmax/kick-data-scraper/examples/export-kick-streamer-stats)
- [Find top live Kick.com streamers by viewers](https://apify.com/aitooolsmax/kick-data-scraper/examples/find-top-kick-streamers-live)

#### Kick Channel Data Lookup

Use when you already know the Kick usernames and want structured public channel profiles.

```json
{
	"mode": "channels",
	"channelSlugs": ["xqc", "trainwreckstv", "asmongold"]
}
```

#### Kick Streamer Stats Snapshot

Use the same channel lookup mode when you want current streamer stat snapshots such as follower count, verification status, live status, and social links.

```json
{
	"mode": "channels",
	"channelSlugs": ["xqc", "trainwreckstv", "asmongold"]
}
```

#### Top Live Kick Streamers

Use live discovery when you want currently live public channels sorted by viewer count.

```json
{
	"mode": "livestreams",
	"livestreamSort": "viewers_high_to_low",
	"maxItems": 50
}
```

### What This Actor Does

- Find channels by **keyword** using Kick search
- Discover channels from one or more **categories**
- Discover **currently live channels** with sort, language, and tag filters
- Extract specific channels when you already know the **Kick usernames**
- Return profile, follower, verification, social link, live status, livestream, and provenance fields

### Which Mode Should I Use?

| Goal | Use `mode` | Fill in |
| ---- | ---------- | ------- |
| I already know the Kick usernames | `channels` | `channelSlugs` |
| I want channels matching a keyword such as `poker`, `gta`, or `casino` | `search` | `searchKeywords` |
| I want channels from Kick categories such as `just-chatting`, `slots`, or `minecraft` | `category` | `categorySlugs`, optional category filters |
| I want currently live channels sorted or filtered by tags/languages | `livestreams` | optional `livestreamSort`, `livestreamLanguages`, `livestreamTags` |

Pick one workflow and fill in the matching fields. If `channels` mode is selected without channel usernames, the actor can infer a discovery mode from clear search/category/livestream inputs and will log the correction.

### Why This Actor Is Different

- **More discovery paths:** exact usernames, Kick search, categories, and live browse filters.
- **Channel snapshot output:** profile data, follower count, verification, social links, live status, and livestream metadata when available.
- **Live discovery controls:** sort by recommended or viewers, filter by language, and filter by Kick stream tags.
- **Category research:** browse multiple category slugs in one run.
- **HTTP-first snapshots:** after discovery, channel profiles are fetched through public channel responses where possible to reduce browser overhead.
- **Provenance fields:** `sourceUrl` and `sourceQuery` show which search, category, or browse page produced each result.
- **PPR guardrails:** `maxItems` is capped and paid dataset item limits are respected.
- **Anti-block handling:** session rotation, retry/backoff behavior, cookie persistence, and browser fallback where needed.

### Typical Use Cases

- Influencer discovery and outreach
- Live channel monitoring by tag or language
- Category benchmarking and market sizing
- Competitive research and benchmarking
- Content and audience research
- Market mapping for agencies

### Input

| Field                 | Type   | Description                                                               |
| --------------------- | ------ | ------------------------------------------------------------------------- |
| `mode`                | string | `channels`, `livestreams`, `search`, `category`                           |
| `channelSlugs`        | array  | Channel usernames (for `channels` mode)                                   |
| `searchKeywords`      | string | Search query (for `search` mode)                                          |
| `categorySlugs`       | array  | Category slugs (for `category` mode)                                      |
| `livestreamSort`      | string | `recommended`, `viewers_high_to_low`, `viewers_low_to_high`               |
| `livestreamLanguages` | array  | Language codes (e.g., `en`, `bg`)                                         |
| `livestreamTags`      | array  | Exact live stream tags with no spaces (e.g., `gaming`, `casual`, `gta`)   |
| `categorySort`        | string | `recommended`, `viewers_high_to_low`, `viewers_low_to_high`               |
| `categoryLanguages`   | array  | Language codes (e.g., `en`, `bg`)                                         |
| `maxItems`            | number | Max results for discovery modes (default: 100, hard cap: 1000, also limited by paid-item cap). Ignored for `channels` mode. |

**Filter behavior:** invalid values are ignored with a warning that names the bad values. Language filters and livestream tags reject empty values, spaces, and values longer than 20 characters. Kick live tags are exact single values such as `gaming`, `casual`, `gta`, or `gambling`. For phrases such as `CS GO`, use `mode: "search"` with `searchKeywords` instead of `livestreamTags`.

**Search note:** Kick search may return fewer channels than `maxItems`. `maxItems` is a cap, not a guarantee.

### Examples

#### 1) Extract Specific Channels

```json
{
	"mode": "channels",
	"channelSlugs": ["xqc", "trainwreckstv", "asmongold"]
}
```

#### 2) Discover Live Channels (Sorted + Filtered)

```json
{
	"mode": "livestreams",
	"livestreamSort": "viewers_high_to_low",
	"livestreamLanguages": ["bg", "en"],
	"livestreamTags": ["gaming", "casual", "gta"],
	"maxItems": 100
}
```

#### 3) Search Channels

```json
{
	"mode": "search",
	"searchKeywords": "poker",
	"maxItems": 25
}
```

#### 4) Browse Categories (Sorted + Filtered)

```json
{
	"mode": "category",
	"categorySlugs": ["just-chatting", "irl"],
	"categorySort": "recommended",
	"categoryLanguages": ["en"],
	"maxItems": 50
}
```

### Output

Each dataset item is a **channel snapshot**:

```json
{
	"type": "channel",
	"channelId": 12345,
	"slug": "xqc",
	"displayName": "xQc",
	"bio": "Channel description...",
	"profileImage": "https://...",
	"bannerImage": "https://...",
	"verified": true,
	"followersCount": 1500000,
	"isLive": true,
	"livestream": {
		"id": 67890,
		"title": "Stream Title",
		"viewerCount": 45000,
		"startedAt": "2024-01-15T18:00:00Z",
		"category": { "name": "Just Chatting" }
	},
	"sourceUrl": "https://kick.com/category/just-chatting?sort=recommended&languages=en",
	"sourceQuery": "just-chatting",
	"socialLinks": [{ "platform": "twitter", "url": "https://twitter.com/..." }],
	"channelUrl": "https://kick.com/xqc",
	"videosUrl": "https://kick.com/xqc/videos",
	"clipsUrl": "https://kick.com/xqc/clips",
	"scrapedAt": "2026-01-01T00:30:00Z"
}
```

#### Provenance Fields

- `sourceUrl`: discovery URL that produced the item (search/category/browse). Always present.
- `sourceQuery`: present only for `search` (search term) and `category` (category slug). Omitted for `channels` and `livestreams`.

### Pricing

PPR pricing is based on **1 dataset item = 1 channel snapshot** (per 1,000 channel snapshots).

### Support

For questions, feature requests, or bug reports, please open an issue on this actor's page.

# Actor input Schema

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

Choose one workflow. Use Get specific channels when you already know Kick usernames. Use Find live channels for live streams sorted or filtered by tags/languages. Use Search by keyword for terms such as poker, gta, or casino. Use Browse categories for category slugs such as just-chatting or slots.

## `channelSlugs` (type: `array`):

Required only for Get specific channels mode. Enter Kick usernames or channel URLs you already know, for example xqc, trainwreckstv, or https://kick.com/asmongold. Discovery fields such as search keywords, categories, and live tags are ignored in this mode.

## `searchKeywords` (type: `string`):

Required only for Search by keyword mode. Searches Kick for channels and livestream results matching this text, then returns channel snapshots for discovered channels. This does not combine with live tag filters.

## `categorySlugs` (type: `array`):

Required only for Browse categories mode. Enter one or more Kick category slugs; each category is browsed separately. Examples: just-chatting, irl, minecraft, slots. If you have a category URL, use the final URL segment.

## `categorySort` (type: `string`):

Sort order for Browse categories mode. Ignored unless mode is Browse categories.

## `categoryLanguages` (type: `array`):

Optional language filters for Browse categories mode. Use language codes such as en, bg, de. Ignored unless mode is Browse categories.

## `livestreamSort` (type: `string`):

Sort order for Find live channels mode. Use this when you want currently live channels, for example highest-viewer streams first.

## `livestreamLanguages` (type: `array`):

Optional language filters for Find live channels mode. Use language codes such as en, bg, de. Ignored unless mode is Find live channels.

## `livestreamTags` (type: `array`):

Optional tag filters for Find live channels mode. Use exact Kick stream tags with no spaces, such as gaming, casual, gta, or gambling. Do not enter search phrases such as CS GO here; use Search by keyword for phrases. Ignored unless mode is Find live channels.

## `maxItems` (type: `integer`):

Maximum channel snapshots to return from Search by keyword, Browse categories, or Find live channels modes. Ignored when using known channel usernames. Hard cap: 1000.

## Actor input object example

```json
{
  "mode": "channels",
  "channelSlugs": [
    "xqc"
  ]
}
```

# Actor output Schema

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

Default dataset containing public Kick.com channel/profile/live stream snapshot records. Use the dataset view selector for channel profiles, streamer stats, and live discovery presentations.

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

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

# Run the Actor and wait for it to finish
run = client.actor("aitooolsmax/kick-data-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 '{
  "channelSlugs": [
    "xqc"
  ]
}' |
apify call aitooolsmax/kick-data-scraper --silent --output-dataset

```

## MCP server setup

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