# Twitch & Kick Scraper — Streams, Channels, Micro-Streamers (`chorelet/live-streams-scraper`) Actor

Live channels and streams from Twitch and Kick in one schema: followers, viewers, category, language, tags and — on Kick — the streamer's social links. Sort by fewest viewers to find micro-streamers. No login or API key.

- **URL**: https://apify.com/chorelet/live-streams-scraper.md
- **Developed by:** [Chorelet](https://apify.com/chorelet) (community)
- **Categories:** Social media, Lead generation, Videos
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 channel profiles

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

## Twitch & Kick Scraper — Streams, Channels, Micro-Streamers

Live channels and streams from **Twitch and Kick in one schema**: followers, viewers, category, language, tags, account age and — on Kick — the social links the streamer published. As JSON, CSV or Excel, or through the API.

Three ways in: browse a category's live channels, look up a list of channels by name, or search both platforms by keyword. No account, no API key, no proxy — everything comes from the endpoints the platforms' own web apps call.

### Why this Actor

- **Two platforms, one table.** Twitch and Kick with identical fields, so a category sweep or a watchlist lands in a single spreadsheet instead of two.
- **Finds the small channels.** Sort by fewest viewers and cap followers, and the run returns streamers with 0–200 followers — the people sponsorship and affiliate programmes look for and ranked lists never show.
- **Socials where they exist.** Kick publishes Instagram, X, YouTube, TikTok and Discord for its streamers; those become links in the row. Twitch hides them from server-side clients and this Actor says so rather than shipping an empty promise.
- **Cheap listings, paid profiles.** A row that rides along with a category page costs a quarter of a row that needed its own profile lookup, so a wide sweep stays cheap.

### Sample output

One item of the dataset (long values shortened):

```json
{
  "platform": "twitch",
  "channelName": "akaNemsko",
  "followers": 380196,
  "isLive": true,
  "viewers": 2570,
  "streamCategory": "Just Chatting",
  "language": "EN",
  "channelUrl": "https://twitch.tv/akanemsko"
}
```

### What you get

- Both platforms, one row shape, with a `platform` column — no second tool for Kick
- **Micro-streamer discovery**: sort a category by fewest viewers and cap the follower count to surface channels with 0–200 followers, the ones sponsorship and affiliate programmes actually want to find
- Kick socials: Instagram, X, YouTube, TikTok, Facebook and Discord, turned into links
- Follower counts, bio and account age for every channel found, with one profile lookup per channel
- Language filter that doubles as a way past Twitch's 100-row cap per category
- Monitored daily

### Input

- **Categories** — `Just Chatting`, `Software and Game Development`, `Chess`. Twitch reads the category's live channels; Kick has no public category listing, so its live feed is filtered by category name.
- **Channels** — names or URLs on either platform.
- **Search queries** — keyword search across both.
- **Sort live channels by** — most viewers, fewest viewers (micro-streamers) or recently started.
- **Languages**, **Minimum/Maximum followers**, **Minimum/Maximum viewers**, **Live channels only**, **Include channel details**, **Max results per target**.

### Limits and notes

- **Twitch does not expose streamer socials to server-side clients.** The field exists in its API but is behind an integrity check that a datacenter IP cannot pass, so `socials` is filled for Kick channels and empty for Twitch ones. This Actor will not pretend otherwise, and it does not try to defeat the check.
- Twitch returns at most 100 live channels per category per request and blocks paging beyond that the same way. Add languages to widen a sweep: each language is a separate request with its own 100.
- Kick publishes no follower count in its live feed or search results — those rows get it from the profile lookup, which is why **Include channel details** is on by default.
- `viewers` is a snapshot at the moment of the run; for a trend, schedule the Actor and keep the dataset.
- Every bound (`minFollowers`, `maxViewers`…) treats `0` as "no limit".

### Input example

```json
{
  "platforms": [
    "twitch",
    "kick"
  ],
  "categories": [
    "Just Chatting"
  ],
  "sortBy": "viewers-desc",
  "minFollowers": 0,
  "maxFollowers": 0,
  "minViewers": 0,
  "maxViewers": 0,
  "onlyLive": false,
  "includeChannelDetails": true,
  "maxResults": 50
}
```

### How much does it cost?

Pay per channel — no subscription, no minimum, no charge for platform usage.

| Volume | Price |
|---|---|
| 1,000 channels | $2.50 (+ $1.00 with `stream`) |
| 10,000 channels | $25.00 (+ $10.00 with `stream`) |
| 100,000 channels | $250.00 (+ $100.00 with `stream`) |

The Apify **free plan includes $5 of usage every month** — about 2,000 channels with this Actor, no card needed. Nothing else is charged: platform usage is included in the price, and Apify Bronze, Silver and Gold subscribers get 10%, 20% and 30% off these prices.

### Use it from code, n8n, Make, Zapier or an AI agent

Run the Actor and download the dataset in one call (JSON by default; add `&format=csv` or `xlsx`):

```bash
curl -X POST "https://api.apify.com/v2/acts/chorelet~live-streams-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"platforms": ["twitch", "kick"], "categories": ["Just Chatting"], "sortBy": "viewers-desc", "minFollowers": 0, "maxFollowers": 0, "minViewers": 0, "maxViewers": 0, "onlyLive": false, "includeChannelDetails": true, "maxResults": 50}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("chorelet/live-streams-scraper").call(run_input={"platforms": ["twitch", "kick"], "categories": ["Just Chatting"], "sortBy": "viewers-desc", "minFollowers": 0, "maxFollowers": 0, "minViewers": 0, "maxViewers": 0, "onlyLive": false, "includeChannelDetails": true, "maxResults": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

- **n8n, Make, Zapier** — use the Apify node/module: run the Actor, then "get dataset items".
- **Google Sheets, Slack, webhooks** — add an integration on the run's *Integrations* tab.
- **AI agents** — the Actor is available as a tool through the Apify MCP server; the dataset schema describes every field for the model.
- **Schedules** — run it hourly, daily or weekly from the *Schedules* tab.

### FAQ

**Can I get Twitch streamers' social links?**

No, and no Actor running on a server can: Twitch puts that field behind an integrity check that datacenter IPs cannot pass. Kick publishes them openly, and this Actor returns them for Kick channels.

**How do I find small streamers to sponsor?**

Pick a category, set *Sort live channels by* to fewest viewers and set *Maximum followers* to your ceiling. A test run on Software and Game Development returned channels with 0, 1, 10 and 90 followers, all live.

**Why do I only get 100 channels from a category?**

That is Twitch's cap per request, and paging past it is blocked. Add languages — each one is a separate request with its own 100 rows — or run several categories.

**What is the difference between a profile row and a listing row?**

A listing row comes from a category or search page and is charged as a stream. A profile row needed its own lookup — that is where the bio, account age, follower count and Kick socials come from — and is charged as a channel.

**Does it need a Twitch or Kick account?**

No. Both platforms serve this data to anonymous visitors, and the Actor uses the same public endpoints their websites do.

### Support

Questions, missing fields or a source that changed? Open an issue on the *Issues* tab or write to support@chorelet.app — problems are usually fixed within a day, and the Actor is checked every morning by an automated test run. If the Actor saved you time, a short review on its Store page helps other people find it.

# Actor input Schema

## `platforms` (type: `array`):

Which platforms to read. Rows from both come back in the same shape, with a `platform` column.

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

Game or category names, e.g. `Just Chatting`, `Software and Game Development`, `Chess`. On Twitch this reads the category's live channels; Kick has no public category listing, so its live feed is filtered by category name.

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

Channel names or URLs, e.g. `pokimane`, `https://twitch.tv/shroud`, `https://kick.com/xqc`. Full profiles with follower counts, bio and — on Kick — social links.

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

Find channels by keyword on both platforms.

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

`viewers-asc` is how you find small channels: it starts at the bottom of a category, where the streamers with 0–5 viewers are.

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

Two-letter broadcast languages, e.g. `en`, `de`, `es`. On Twitch each language is a separate request, which is also how you get past the 100-row cap per category.

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

Drop channels below this follower count.

## `maxFollowers` (type: `integer`):

Drop channels above this follower count — the micro-streamer filter.

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

Drop streams below this viewer count.

## `maxViewers` (type: `integer`):

Drop streams above this viewer count.

## `onlyLive` (type: `boolean`):

Keep only channels that are streaming right now.

## `includeChannelDetails` (type: `boolean`):

Look up the full profile of every channel found in a listing: bio, account age, follower count and, on Kick, social links. One extra request per batch on Twitch and per channel on Kick — these rows are charged as profiles.

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

A target is one category, one search query or the channel list.

## Actor input object example

```json
{
  "platforms": [
    "twitch",
    "kick"
  ],
  "categories": [
    "Just Chatting"
  ],
  "channels": [],
  "searchQueries": [],
  "sortBy": "viewers-desc",
  "languages": [],
  "onlyLive": false,
  "includeChannelDetails": true,
  "maxResults": 50
}
```

# Actor output Schema

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

All channels — items of the default dataset. Use ?format=csv or xlsx on this URL for spreadsheets.

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

Rows per target, profiles versus listings, API calls and errors.

# 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 = {
    "platforms": [
        "twitch",
        "kick"
    ],
    "categories": [
        "Just Chatting"
    ],
    "channels": [],
    "searchQueries": [],
    "sortBy": "viewers-desc",
    "languages": [],
    "minFollowers": 0,
    "maxFollowers": 0,
    "minViewers": 0,
    "maxViewers": 0,
    "onlyLive": false,
    "includeChannelDetails": true,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("chorelet/live-streams-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 = {
    "platforms": [
        "twitch",
        "kick",
    ],
    "categories": ["Just Chatting"],
    "channels": [],
    "searchQueries": [],
    "sortBy": "viewers-desc",
    "languages": [],
    "minFollowers": 0,
    "maxFollowers": 0,
    "minViewers": 0,
    "maxViewers": 0,
    "onlyLive": False,
    "includeChannelDetails": True,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("chorelet/live-streams-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 '{
  "platforms": [
    "twitch",
    "kick"
  ],
  "categories": [
    "Just Chatting"
  ],
  "channels": [],
  "searchQueries": [],
  "sortBy": "viewers-desc",
  "languages": [],
  "minFollowers": 0,
  "maxFollowers": 0,
  "minViewers": 0,
  "maxViewers": 0,
  "onlyLive": false,
  "includeChannelDetails": true,
  "maxResults": 50
}' |
apify call chorelet/live-streams-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,chorelet/live-streams-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/yGgZpf1qHYZwNpjZ3/builds/YEicepFe7FSm4qHg5/openapi.json