# Twitch Channel Scraper: Followers, Live Status & VODs (`accountable_eel/twitch-channel-lookup`) Actor

Check if a Twitch channel is live and its viewers, game and stream title, plus follower count, recent VODs and about panel links, for a list of channels. Streamer stats to Google Sheets, API or n8n. Went-live monitoring with alerts to Discord or Slack webhooks.

- **URL**: https://apify.com/accountable_eel/twitch-channel-lookup.md
- **Developed by:** [Adriana Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 twitch channel returneds

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 "Went Live" Webhook & Channel Scraper for AI Agents & Discord

**Automated "Went Live" webhook alerts and real-time Twitch channel intelligence designed for AI agents, Discord bots, and community automation.** Receive instant, zero-latency webhook notifications to Discord, Slack, Telegram, or custom AI endpoints the moment a streamer goes live or publishes a new VOD.

Batch-optimized with GraphQL aliases (up to 20 channels per request) for near-instant execution and minimal cost. Keyless by default — no Twitch account, developer app, or API credentials required.

***

### 🔥 Primary Feature: "Went Live" Webhooks for Discord & AI Agents

Never miss a Twitch broadcast again. Whether you are building an automated Discord community bot or feeding real-time streamer activity into an AI agent workflow, this actor provides stateful, zero-overhead stream detection:

- **Discord Community Alerts:** Send rich formatted embed notifications directly to your Discord server's webhook channel with stream titles, live viewer counts, category/game info, and instant stream links.
- **AI Agent Event Triggers:** Trigger autonomous AI agents (via Webhooks, MCP, n8n, Make, or custom API listeners) when creators go live, enabling automated live-tweeting, AI stream summaries, or dynamic community announcements.
- **Zero-Cost Quiet Runs (`onlyChangesSinceLastRun`):** When monitoring on a schedule (e.g. every 3–5 minutes), quiet runs with no status changes withhold output and cost **$0** for item processing. You only pay when a stream state change actually occurs!

***

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `channels` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~twitch-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"channels":["shroud","pokimane"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

***

### ⚡ Setting Up Went-Live Webhook Alerts

To enable continuous tracking and automatic webhook notifications:

1. **Set `onlyChangesSinceLastRun: true`** — Enables stateful monitoring (tracked via Apify named store `twitch-channel-lookup-delta`).
2. **Provide `notifyUrl`** — Paste your Discord Webhook URL, Telegram bot webhook, Slack webhook, or AI Agent API endpoint.
3. **Select `notifyFormat`**:
   - `discord`: Formats beautiful rich cards with stream title, game, viewer count, and stream URL.
   - `slack` / `telegram`: Formats platform-native message alerts.
   - `json` / `auto`: Sends raw JSON payloads perfect for AI Agents, n8n, or custom microservices.

#### Discord & AI Agent Webhook Payload Example

When a monitored channel goes live, your webhook receives an event payload like:

```json
{
  "login": "shroud",
  "displayName": "shroud",
  "channelUrl": "https://www.twitch.tv/shroud",
  "isLive": true,
  "streamTitle": "VALORANT RANKED WITH FRIENDS!",
  "gameName": "VALORANT",
  "viewersCount": 18450,
  "changeType": "WENT_LIVE",
  "isNew": true,
  "scrapedAt": "2026-10-08T02:00:00.000Z"
}
```

***

### Input

```json
{
  "channels": [
    "shroud",
    "pokimane"
  ]
}
```

One channel per line. Enter a Twitch login username (e.g. shroud) or a channel URL (e.g. https://www.twitch.tv/pokimane). Accepted formats: \[object Object], \[object Object].

#### Configuration Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `channels` | array | **Required** | List of Twitch usernames or channel URLs to inspect. |
| `onlyChangesSinceLastRun` | boolean | `false` | Enable monitoring mode. Only emits data when a channel goes live or posts a new VOD. |
| `notifyUrl` | string (secret) | `""` | Destination webhook URL (Discord Webhook, AI Agent HTTP endpoint, Slack, Telegram). |
| `notifyFormat` | select | `"auto"` | Message styling: `discord`, `slack`, `telegram`, `json`, or `auto`. |
| `includeVideos` | boolean | `true` | Includes latest VOD recordings (title, duration, views, published date, URL). |
| `includePanels` | boolean | `true` | Extracts links and titles from channel about panels (sponsors, socials, gear). |
| `deltaName` | string | `""` | Custom watchlist identifier for state tracking in the named store. |
| `maxNotificationsPerRun` | integer | `10` | Cap on webhook alert messages sent per single run. |

***

### Output

One row per channel:

| query | found | status | login | displayName | channelUrl | description | followers | isPartner | isAffiliate | createdAt | isLive | viewersCount | streamTitle | gameName | lastStreamAt | lastStreamTitle | recentVideos | socialLinks | panelLinks | changeType | isNew | notifyErrors | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| shroud | true | OK | <login> | <display name> | <channel url> | <description> | <followers> | <partner> | <affiliate> | <created at> | <is live> | <current viewers> | <stream title> | \<game / category> | <last stream at> | <last stream title> | <recent vods> | <social links> | <panel links> | <change type> | <is new> | <notification errors> | 1970-01-01T00:00:00.000Z |

Unknown channel usernames return `"found": false` with status `"NOT_FOUND"` and are never charged.

***

### Pricing

$3 per 1,000 Twitch channels, plus a $0.0015 start fee. Misses (`found:false`) are never charged.

- **On-demand lookup mode:** Charged once per found channel ($0.003 FREE tier).
- **Monitoring mode (`onlyChangesSinceLastRun: true`):** Charged only when a channel goes live or publishes a new VOD. Quiet runs with no changes cost **$0** per item.

***

### Use it from AI Agents, n8n, Make, or Clay

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~twitch-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"channels":["shroud","pokimane"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~twitch-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"channels":["shroud","pokimane"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~twitch-channel-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"channels":["{{Twitch channel}}"]}`, mapping the row's Twitch channel into the `channels` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Twitch channel scraper followers and live status" — the agent will find and run this actor.

***

### Example Use Cases

1. **Automated Discord Community Live Alerts:**
   Set up an Apify schedule running every 3 minutes with your community's Twitch channels and your Discord webhook URL. Your Discord server gets instant live notifications with thumbnail cards.

2. **AI Agent Live Stream Monitor:**
   Connect your AI workflow (via LangChain, CrewAI, or n8n) to monitor when key streamers start broadcasting. Automatically send summarized stream alerts or update live event dashboards.

3. **Creator Vetting & CRM Enrichment:**
   Instantly fetch follower counts, channel creation dates, affiliate/partner status, and social media/panel sponsor links for marketing outreach.

***

### Technical Details & Official Twitch API Fallback

This actor utilizes Twitch's high-speed public web GraphQL endpoints for keyless access without requiring Twitch API application approval.

If you prefer to connect directly using official credentials, you can use the **Twitch Helix REST API**:

1. Register an application in the [Twitch Developer Console](https://dev.twitch.tv/console).
2. Obtain your **Client ID** and **Client Secret**.
3. Authenticate via OAuth client credentials:
   `POST https://id.twitch.tv/oauth2/token?client_id=<ID>&client_secret=<SECRET>&grant_type=client_credentials`
4. Request Twitch Helix endpoints:
   - User profile: `GET https://api.twitch.tv/helix/users?login=<channel>`
   - Stream status: `GET https://api.twitch.tv/helix/streams?user_login=<channel>`
   - Followers count: `GET https://api.twitch.tv/helix/channels/followers?broadcaster_id=<id>`

***

### What this is not

- **Not an IRC or chat bot:** Does not read or send Twitch chat messages.
- **Not a stream recorder:** Extracts stream status, metadata, and VOD details, but does not download video streams or MP4 binaries.
- **Not unauthorized access:** Queries public web interfaces built for web browser display.

# Actor input Schema

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

One channel per line. Enter a Twitch login username (e.g. shroud) or a channel URL (e.g. https://www.twitch.tv/pokimane). Accepted formats: \[object Object], \[object Object]. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

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

When checked, fetches the 5 latest VODs for each channel (id, title, publishedAt, lengthSeconds, viewCount, url).

## `includePanels` (type: `boolean`):

When checked, extracts links from the channel's about panels (sponsors, donations, social media, merch).

## `onlyChangesSinceLastRun` (type: `boolean`):

On: only emits a row when a channel went live (was offline last run) or has a new VOD. Unchanged channels are withheld and not billed. Perfect for scheduled went-live alerts. Off: every found channel is returned every run.

## `deltaName` (type: `string`):

Optional. Name this watchlist's monitoring memory so you can keep two schedules of this actor apart, or preserve memory across channel list changes. Leave empty to auto-derive.

## `notifyUrl` (type: `string`):

Optional. When monitoring is on, each went-live or new-VOD change triggers an alert posted here. Discord/Slack: paste webhook URL. Telegram: https://api.telegram.org/bot<token>/sendMessage?chat_id=\<chat_id>. Any other URL receives JSON. Stored encrypted, never logged.

## `notifyFormat` (type: `string`):

Leave on 'Detect from the link': discord.com links get Discord format, hooks.slack.com gets Slack, api.telegram.org gets Telegram, any other destination receives JSON.

## `maxNotificationsPerRun` (type: `integer`):

Up to 100. Above this, one summary message says how many more channels changed. 0 sends only the summary message.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "channels": [
    "shroud",
    "pokimane"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "includeVideos": true,
  "includePanels": true,
  "onlyChangesSinceLastRun": false,
  "deltaName": "",
  "notifyFormat": "auto",
  "maxNotificationsPerRun": 10,
  "columns": [
    "login",
    "displayName",
    "channelUrl",
    "description",
    "followers",
    "isPartner",
    "isAffiliate",
    "createdAt",
    "isLive",
    "viewersCount",
    "streamTitle",
    "gameName",
    "lastStreamAt",
    "lastStreamTitle",
    "recentVideos",
    "socialLinks",
    "panelLinks",
    "changeType",
    "isNew",
    "notifyErrors"
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "channels": [
        "shroud",
        "pokimane"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/twitch-channel-lookup").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": [
        "shroud",
        "pokimane",
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/twitch-channel-lookup").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": [
    "shroud",
    "pokimane"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/twitch-channel-lookup --silent --output-dataset

```

## MCP server setup

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

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/4rBo55uUb7xsuZJUi/builds/ghAoUDPOGlWbjjFSh/openapi.json