# Kick Scraper (`automation-lab/kick-streamer-channel-analytics`) Actor

Discover or look up public Kick creators and export channel identity, followers, live status, audience signals, categories, recent videos, recent clips, and source URLs.

- **URL**: https://apify.com/automation-lab/kick-streamer-channel-analytics.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Kick Scraper

Discover public Kick creators or look up known channels and export one analysis-ready record per streamer. The Actor combines channel identity, follower and verification signals, current live status, category, audience indicators, and bounded recent video and clip summaries.

Use it for creator discovery, sponsorship research, livestream-market monitoring, and repeatable Kick streaming data exports. It does not require a Kick account, API credential, browser, or proxy configuration.

### What does Kick Scraper do?

Kick Scraper supports three complementary routes:

1. look up exact public channel URLs or usernames;
2. search Kick by creator name or keyword;
3. discover channels in Kick's featured live feed.

Every route produces the same typed channel record. Optional `liveOnly` and `category` filters are applied consistently to exact lookups, search results, and featured discovery. Recent videos and clips are nested in the channel record, so spreadsheets and data pipelines receive one stable row per creator rather than unrelated record types.

### Who is this Kick streamer data for?

- **Influencer and sponsorship teams** building candidate lists with follower, verification, category, and current-audience context.
- **Livestream analysts** comparing who is live, what category they stream, and visible concurrent viewer counts.
- **Creator managers** checking a known roster and collecting recent channel activity.
- **Data teams** scheduling recurring exports into Sheets, warehouses, dashboards, or monitoring workflows.
- **Developers** who need a managed Kick API-style workflow without maintaining TLS impersonation or pagination code.

### Why use this Actor?

- Search, exact lookup, and live discovery share one output contract.
- Each result includes recent video and clip summaries when requested.
- The Actor uses structured public endpoints rather than rendering pages or downloading media.
- Limits are explicit: at most 500 channel rows, 25 videos, and 25 clips per channel.
- Stable channel IDs and URLs make repeat-run comparison straightforward.
- You pay for accepted channel records, not each nested video or clip.

### What Kick channel data can I extract?

| Area | Example fields |
| --- | --- |
| Identity | `channelId`, `userId`, `username`, `slug`, `channelUrl`, `profilePictureUrl`, `bio` |
| Audience | `followersCount`, `verified`, `affiliate` |
| Channel state | `banned`, `isLive` |
| Current stream | `liveTitle`, `liveViewerCount`, `liveStartedAt`, `language`, `currentCategory` |
| Channel history | `recentCategories` |
| Recent VODs | title, start time, duration, viewer count, language, category, thumbnail, URL |
| Recent clips | title, creation time, duration, views, likes, category, creator, thumbnail, URL |
| Provenance | `discoveryMethod`, `discoveryValue`, `scrapedAt` |

Upstream fields can be unavailable. Nullable output fields remain `null` instead of receiving guessed values.

### How to scrape Kick channels

1. Open the Actor input.
2. Choose at least one route: `startUrls`, `channelSlugs`, `searchQueries`, or `discoverFeatured`.
3. Optionally keep only currently live channels or supply a category filter.
4. Choose whether to enrich channels with recent videos and clips.
5. Set `maxItems` to the maximum number of channel records you need.
6. Start the run and open the default dataset.
7. Export JSON, CSV, Excel, XML, RSS, or connect the dataset to another Apify integration.

A useful first run is the prefilled `https://kick.com/xqc` channel lookup. It emits one enriched channel record.

### Input parameters

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `startUrls` | array | xQc channel prefill | Exact public Kick channel URLs. |
| `channelSlugs` | string array | `[]` | Exact channel usernames or slugs. |
| `searchQueries` | string array | `[]` | Creator names or keywords searched on Kick. |
| `discoverFeatured` | boolean | `false` | Discover channels from the featured live feed. |
| `liveOnly` | boolean | `false` | Keep channels live at scrape time. |
| `category` | string | unset | Case-insensitive current/recent category name or slug filter. |
| `includeVideos` | boolean | `true` | Add recent VOD summaries to each channel. |
| `videosLimit` | integer | `5` | Videos per channel, from 0 to 25. |
| `includeClips` | boolean | `true` | Add recent clip summaries to each channel. |
| `clipsLimit` | integer | `5` | Clips per channel, from 0 to 25. |
| `maxItems` | integer | `25` | Maximum channel records, from 1 to 500. |

Channel URLs must use `kick.com`. Invalid hosts, blank slugs, blank filters, and out-of-range limits fail with a clear error rather than silently broadening the run.

### Example inputs

Search Kick for creators and enrich the first three matches:

```json
{
  "searchQueries": ["xqc"],
  "videosLimit": 2,
  "clipsLimit": 2,
  "maxItems": 3
}
```

Look up a known channel:

```json
{
  "startUrls": [{ "url": "https://kick.com/xqc" }],
  "videosLimit": 5,
  "clipsLimit": 5,
  "maxItems": 1
}
```

Discover ten currently featured livestreamers without media enrichment:

```json
{
  "discoverFeatured": true,
  "liveOnly": true,
  "includeVideos": false,
  "includeClips": false,
  "maxItems": 10
}
```

### Output example

The default dataset contains one object per accepted channel. This shortened example mirrors the current output shape; counts and live status change over time.

```json
{
  "channelId": 12345,
  "userId": 23456,
  "username": "example_streamer",
  "slug": "example_streamer",
  "channelUrl": "https://kick.com/example_streamer",
  "profilePictureUrl": "https://files.kick.com/images/user/23456/profile.webp",
  "bio": "Gaming and conversation streams.",
  "followersCount": 125000,
  "verified": true,
  "affiliate": false,
  "banned": false,
  "isLive": true,
  "liveTitle": "Evening community stream",
  "liveViewerCount": 4200,
  "liveStartedAt": "2025-01-15T12:00:00.000Z",
  "language": "English",
  "currentCategory": {
    "id": 15,
    "name": "Just Chatting",
    "slug": "just-chatting"
  },
  "recentCategories": [],
  "recentVideos": [],
  "recentClips": [],
  "discoveryMethod": "search",
  "discoveryValue": "gaming",
  "scrapedAt": "2025-01-15T12:05:00.000Z"
}
```

Nested arrays follow the limits in your input. Disabling videos or clips returns an empty array for that section.

### How much does it cost to scrape Kick channels?

The Actor uses pay-per-event pricing: **$0.005 per run** plus one `item` event for every accepted channel written to the default dataset. Videos and clips nested in that channel record do not trigger separate events.

| Apify tier | Price per channel |
| --- | ---: |
| FREE | $0.0036432 |
| BRONZE | $0.003168 |
| SILVER | $0.002471 |
| GOLD | $0.0019008 |
| PLATINUM | $0.0012672 |
| DIAMOND | $0.00088704 |

At BRONZE, 1 accepted channel costs about **$0.0082**, 10 cost about **$0.0367**, and 100 cost about **$0.3218**, including the one-time start event. Runtime platform usage is covered by this PPE pricing configuration.

For an exact estimate, calculate:

`$0.005 + (accepted channel rows × your active item tier)`

Filters can reduce the number of accepted rows below `maxItems`. Failed, duplicate, and filtered-out candidates are not emitted as item records.

### Recurring monitoring workflows

A scheduled run can capture a comparable snapshot of selected channels or currently featured creators. Use `channelSlugs` for a stable roster and `discoverFeatured` for changing market coverage.

Suggested flow:

1. schedule the Actor hourly, daily, or weekly;
2. keep `channelId` as the stable entity key;
3. store `scrapedAt`, `isLive`, `liveViewerCount`, category, and follower count;
4. compare each row with the previous run in your database or automation;
5. alert only on changes relevant to your campaign or research.

The Actor exports observations. It does not maintain historical diffs or send alerts by itself.

### Spreadsheet and data-pipeline exports

From the dataset page, export the overview as CSV or Excel for manual analysis. For automated pipelines, request JSON from the dataset API and upsert by `channelId`.

Good downstream patterns include:

- append daily channel snapshots to BigQuery or Snowflake;
- update creator research rows in Airtable or Google Sheets;
- send currently live channels to Slack through Make or Zapier;
- rank candidates by follower and visible live-viewer signals;
- join Kick creator data with an internal sponsorship CRM.

### API access with cURL

Start a run through the Apify API:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~kick-streamer-channel-analytics/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["xqc"],
    "videosLimit": 2,
    "clipsLimit": 2,
    "maxItems": 3
  }'
```

Wait for completion, then read the run's `defaultDatasetId` and fetch its items.

### API access with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/kick-streamer-channel-analytics').call({
  channelSlugs: ['xqc'],
  videosLimit: 5,
  clipsLimit: 5,
  maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API access with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/kick-streamer-channel-analytics").call(
    run_input={
        "discoverFeatured": True,
        "liveOnly": True,
        "includeVideos": False,
        "includeClips": False,
        "maxItems": 10,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Kick Scraper through MCP

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/kick-streamer-channel-analytics"
```

For **Claude Desktop**, add this remote server under `mcpServers` in its configuration file. **Cursor** users can add the same JSON in MCP settings, and **VS Code** users can add it through their MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/kick-streamer-channel-analytics"
    }
  }
}
```

Example prompts:

- “Search Kick for xQc and return the first three enriched channels.”
- “Look up these Kick usernames and show follower count, live status, and category.”
- “Discover ten featured live Kick creators without fetching clips or videos.”

### Tips for efficient runs

- Disable `includeVideos` and `includeClips` when you only need current channel or livestream state.
- Use exact channel slugs for recurring roster monitoring.
- Start search runs with a small `maxItems`; search terms can match multiple channels.
- Keep media limits low for frequent schedules and raise them only when content history is needed.
- Combine `discoverFeatured` with `liveOnly` for a focused current-market snapshot.
- Use the category filter after testing the exact category name or slug shown by Kick.

### Limits and data freshness

Kick controls the public endpoints and can change fields, ordering, availability, or rate limits. `followersCount`, live-viewer values, and current status are point-in-time observations. A channel can go offline between discovery and enrichment.

Search relevance and the featured feed are controlled by Kick. The Actor does not promise exhaustive platform coverage. Recent video and clip endpoints return the source's available order and are capped at 25 summaries per channel by this Actor.

Private, deleted, banned, renamed, or unavailable channels may not produce a row. If every discovered candidate is unavailable after bounded retries, the run fails instead of returning a misleading successful empty dataset.

### Troubleshooting

#### Why did a search return no rows?

Kick may have no channel match for the query. Try a known channel username, use a direct URL, or broaden the query. A legitimate search with no matches completes with an empty dataset.

#### Why are live fields null?

`liveTitle`, `liveViewerCount`, `liveStartedAt`, `language`, and `currentCategory` are expected to be null while a channel is offline.

#### Why are recent videos or clips empty?

The channel may have no public recent media, VODs may be disabled, or your input disabled that enrichment. Check `includeVideos`, `videosLimit`, `includeClips`, and `clipsLimit`.

#### Why did the run fail for a channel URL?

Confirm the URL uses `kick.com` and points to a public channel rather than a video, clip, category, or unrelated path. Supply the channel's first path segment only.

### Responsible use and legality

This Actor collects public Kick data available without login. You are responsible for complying with Kick's terms, applicable privacy and database laws, and the rules governing your intended use.

Do not use output for harassment, invasive profiling, discrimination, unsolicited spam, or attempts to access private information. Minimize stored personal data, secure exports, define a retention period, and honor valid deletion or correction obligations.

### Related Automation Lab Actors

- [YouTube Live Stream Scraper](https://apify.com/automation-lab/youtube-live-stream-scraper) for public YouTube livestream discovery and channel context.
- [Cross-platform Influencer Discovery](https://apify.com/automation-lab/cross-platform-influencer-discovery) for broader creator prospecting across supported networks.
- [YouTube Channel Videos Scraper](https://apify.com/automation-lab/youtube-channel-videos-scraper) for channel-level YouTube video exports.

Choose this Actor when Kick is the source and you need channel identity, live status, audience context, and recent media in one row.

### FAQ

#### Does Kick Scraper require a Kick API key?

No. Users provide public URLs, usernames, searches, or featured-discovery settings. No Kick credential is requested.

#### Does it download videos or clips?

No. It exports public metadata and source URLs. It does not download or store media files.

#### Can I scrape only live channels?

Yes. Set `liveOnly` to `true`. The filter applies to exact URLs, usernames, search results, and featured discovery.

#### Can I filter by category?

Yes. Provide a case-insensitive category name or slug. The Actor compares it with the current and recent categories available on each enriched channel.

#### Are videos and clips charged separately?

No. The only per-record event is the accepted channel item. Nested videos and clips do not create separate charge events.

#### Can I monitor follower or viewer changes?

Yes, by scheduling repeat runs and comparing snapshots externally. The Actor does not maintain a history table or send alerts itself.

#### Is the output complete for every Kick creator?

No. Exact lookups cover supplied public channels. Search and featured discovery follow Kick's current public result sets and ordering; they are not a complete platform index.

# Actor input Schema

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

Public Kick channel URLs to look up, for example https://kick.com/xqc.

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

Kick channel usernames or slugs to look up directly.

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

Keywords or channel names to search on Kick. Matching channels are enriched with current analytics.

## `discoverFeatured` (type: `boolean`):

Include channels from Kick's paginated featured livestream feed.

## `liveOnly` (type: `boolean`):

Keep only channels that are live when the Actor runs. This filter also applies to direct URLs and searches.

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

Optional case-insensitive category name or slug filter, such as Just Chatting. It applies to every input route.

## `includeVideos` (type: `boolean`):

Fetch recent VOD metadata for each accepted channel.

## `videosLimit` (type: `integer`):

Maximum recent videos included inside each channel record.

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

Fetch recent public clip metadata for each accepted channel.

## `clipsLimit` (type: `integer`):

Maximum recent clips included inside each channel record.

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

Maximum enriched channel records saved to the default dataset.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://kick.com/xqc"
    }
  ],
  "channelSlugs": [],
  "searchQueries": [],
  "discoverFeatured": false,
  "liveOnly": false,
  "includeVideos": true,
  "videosLimit": 5,
  "includeClips": true,
  "clipsLimit": 5,
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Enriched channel, audience, live status, video, and clip data.

# 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 = {
    "startUrls": [
        {
            "url": "https://kick.com/xqc"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/kick-streamer-channel-analytics").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 = {
    "startUrls": [{ "url": "https://kick.com/xqc" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/kick-streamer-channel-analytics").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 '{
  "startUrls": [
    {
      "url": "https://kick.com/xqc"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/kick-streamer-channel-analytics --silent --output-dataset

```

## MCP server setup

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

```

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/mYRFeTfeGvihnqB3t/builds/SNe9J4NqEEzvr6shE/openapi.json