# Twitch Channel Stream Schedule Scraper (`automation-lab/twitch-channel-stream-schedule-scraper`) Actor

Export public Twitch stream schedules for creator campaigns, partnership planning, and channel availability monitoring.

- **URL**: https://apify.com/automation-lab/twitch-channel-stream-schedule-scraper.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

## Twitch Channel Stream Schedule Scraper

Export upcoming public Twitch schedule segments for creator campaigns, partnership planning, and channel availability monitoring.

### What does it do?

This actor reads the public schedule exposed by Twitch for each channel you provide. It creates one dataset row for each visible schedule segment.

Use it to turn a list of creators or esports channels into structured schedule data. No Twitch account, user cookie, or personal credential is required.

### Who is it for?

- 🎯 Creator agencies planning sponsorship timing.
- 📅 Partnership teams checking public creator availability.
- 🎮 Esports operators tracking programming windows.
- 🔄 Automation teams that need repeatable schedule exports.

### Why use it?

Public schedule pages are useful but hard to compare across many channels. This scraper standardizes the data into UTC timestamps and stable segment IDs.

It intentionally focuses on schedule monitoring rather than profiles, streams, clips, chat, or follower data.

### Data you receive

| Field | Description |
| --- | --- |
| `channelLogin` | Twitch channel login |
| `channelName` | Public display name |
| `segmentId` | Public schedule segment identifier |
| `title` | Segment title when available |
| `startAt` | Start timestamp in UTC |
| `endAt` | End timestamp in UTC when supplied |
| `durationMinutes` | Calculated duration when an end time exists |
| `isCancelled` | Public cancellation flag |
| `sourceUrl` | Canonical public schedule URL |

### Start in three steps

1. Add channel logins or public Twitch channel URLs.
2. Set a maximum segment count per channel.
3. Run the actor and export the default dataset as JSON, CSV, Excel, or through the API.

### Input: channel logins

Use `channelLogins` for clean channel identifiers such as `criticalrole`, `cohhcarnage`, or `twitchrivals`.

```json
{"channelLogins":["criticalrole","cohhcarnage"],"maxSegmentsPerChannel":20}
```

### Input: channel URLs

You can also provide public channel or schedule URLs. Both forms resolve to the channel login.

```json
{"channelUrls":[{"url":"https://www.twitch.tv/criticalrole/schedule"}],"maxSegmentsPerChannel":30}
```

### Input limits

`maxSegmentsPerChannel` caps exported public segments for every channel. Start with 20 while validating a workflow, then increase it for planning exports.

The actor de-duplicates channel inputs before requesting Twitch.

### Output example

```json
{"channelLogin":"hasanabi","channelName":"HasanAbi","title":"news + reacts + gaming later","startAt":"2026-07-06T18:00:00.000Z","endAt":"2026-07-07T06:00:00.000Z","durationMinutes":720,"isCancelled":false,"timezone":"UTC"}
```

### Empty schedules

A public channel may have no planned segments. That is a valid result: the run succeeds and emits no row for that channel.

A missing channel is logged and skipped so it does not stop the remaining inputs.

### Timezone behavior

All timestamps are normalized to UTC. This avoids local timezone ambiguity when comparing creators in different regions.

Use `startAt` and `endAt` in your downstream system to render a local timezone if needed.

### Cancellation behavior

The actor preserves Twitch's public `isCancelled` value. Keep cancelled rows in a monitoring workflow to identify changes between schedule exports.

### End times and duration

Some public Twitch schedule segments do not include an end time. In that case, `endAt` and `durationMinutes` are `null`; the actor does not invent a duration.

### Pricing

### How much does it cost to scrape Twitch stream schedules?

Each run has a `$0.005` start charge plus one charge for every exported schedule segment. Per-segment pricing follows your Apify plan tier:

| Apify plan tier | Per exported segment | Approximate total for 20 segments\* |
| --- | ---: | ---: |
| Free | `$0.00012420` | `$0.00748` |
| Bronze | `$0.00010800` | `$0.00716` |
| Silver | `$0.00008424` | `$0.00668` |
| Gold | `$0.00006480` | `$0.00630` |
| Platinum | `$0.00004320` | `$0.00586` |
| Diamond | `$0.00003024` | `$0.00560` |

\*Estimate = the `$0.005` start charge plus 20 exported segments. A Free-plan run that exports 20 segments is therefore about `$0.00748`. Empty public schedules produce no per-segment charges, though the run start charge still applies.

For predictable cost, use the segment limit and export only the channels relevant to your campaign or monitoring list. The live Apify pricing panel is authoritative if platform pricing changes.

### Integrations

- 📊 Send the dataset to Google Sheets for an editorial calendar.
- 🔔 Compare exports on a schedule and alert when a title, time, or cancellation state changes.
- 🧩 Join schedule rows with your creator CRM using `channelLogin`.
- 📆 Convert `startAt` and `endAt` into calendar events in an internal workflow.

### API usage

Use the Apify API to start an export and retrieve its default dataset.

### JavaScript API

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/twitch-channel-stream-schedule-scraper').call({ channelLogins: ['criticalrole'], maxSegmentsPerChannel: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/twitch-channel-stream-schedule-scraper').call(run_input={'channelLogins':['criticalrole'], 'maxSegmentsPerChannel':20})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

### cURL API

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~twitch-channel-stream-schedule-scraper/runs?token=YOUR_APIFY_TOKEN' -H 'content-type: application/json' -d '{"channelLogins":["criticalrole"],"maxSegmentsPerChannel":20}'
```

### MCP

Use this actor through Apify MCP in Claude Code or another MCP-compatible client.

#### Claude Code

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/twitch-channel-stream-schedule-scraper
```

#### Claude Desktop

Add this server to your Claude Desktop MCP configuration:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com/?tools=automation-lab/twitch-channel-stream-schedule-scraper"}}}
```

#### Cursor

Add the same `apify` server URL under **Settings → Tools & MCP → New MCP Server**.

#### VS Code

Add the same `apify` server URL to your workspace MCP configuration and start it from the MCP servers view.

Example prompts: “Export the next public Twitch schedule segments for Riot Games and HasanAbi.” Or: “Compare the upcoming schedule availability for these creator channels and return cancelled segments.”

The MCP workflow is useful for quick campaign availability checks without manually downloading a dataset.

### Legality

Only collect public schedule information for lawful, authorized business purposes. Follow Twitch terms, applicable privacy law, and agreements you have with creators.

### Data source and access

The actor accesses public schedule data exposed by Twitch's web experience. It does not use a Twitch user login, private channel data, or a creator account.

Only submit channels and use exported information in ways permitted by applicable law, Twitch terms, and your agreements with creators.

### Reliability notes

Public schedule availability can change at any time. Twitch may return no schedule for a valid channel, and it may omit end times or titles.

The actor skips individual unavailable channels and continues with the rest of the list. Review logs for skipped inputs.

### Tips for monitoring

Use the same channel list on a regular schedule. Save a previous dataset and compare `segmentId`, `startAt`, `title`, and `isCancelled` to detect change.

For campaign operations, start with a small list of confirmed channels rather than scraping unrelated profiles.

### Troubleshooting: no rows

First open the channel's public `/schedule` page in a browser. If it shows no schedule, the actor has nothing public to export.

A successful run with zero rows is not an error for an empty public schedule.

### Troubleshooting: invalid channel

Provide a Twitch login, a channel URL, or a `/schedule` URL. Do not provide video, clip, directory, or chat URLs.

The actor ignores malformed or missing channel inputs and logs the skipped value.

### FAQ: do I need Twitch credentials?

No. This actor is designed for anonymous access to public schedules only.

### FAQ: can it scrape streams or clips?

No. Use a dedicated Twitch stream or video actor for those workflows. This schedule-focused actor deliberately keeps the output contract narrow.

### FAQ: why is recurrence unknown?

Twitch's public unauthenticated schedule response does not expose a recurrence-rule field. The actor reports `recurrenceState: "unknown"` rather than guessing.

### Related scrapers

For broader public Twitch channel, stream, game, or clip collection, see [Twitch Scraper](https://apify.com/automation-lab/twitch-scraper).

Use this actor when the buyer needs planned availability, not general Twitch discovery.

### Privacy and compliance

The output is limited to public channel schedule information. Do not use it to infer private activity, target protected groups, or violate creator agreements.

Always verify your intended use and retention rules before connecting the data to a CRM or outreach process.

### Support

When reporting an issue, include one sample channel login, the run ID, and whether the public `/schedule` page showed a segment at the time of the run. This makes schedule changes easier to diagnose.

### Change detection fields

Store `segmentId` as your primary row key. A changed `startAt`, `endAt`, title, or cancellation flag for the same ID signals a schedule update.

Treat a missing row carefully: creators can remove a future segment, or Twitch can temporarily expose no public schedule.

### Operational example

A partnership team can run this actor every morning for a curated creator list. Filter rows by the next seven days, map timestamps to the campaign timezone, then notify the producer when a planned segment moves or is cancelled.

# Actor input Schema

## `channelLogins` (type: `array`):

Twitch login names, for example criticalrole. Use this or channel URLs.

## `channelUrls` (type: `array`):

Twitch channel or /schedule URLs. Logins and URLs can be combined.

## `maxSegmentsPerChannel` (type: `integer`):

Caps exported upcoming public segments per channel.

## Actor input object example

```json
{
  "channelLogins": [
    "criticalrole",
    "cohhcarnage",
    "twitchrivals"
  ],
  "channelUrls": [
    {
      "url": "https://www.twitch.tv/criticalrole/schedule"
    }
  ],
  "maxSegmentsPerChannel": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "channelLogins": [
        "criticalrole",
        "cohhcarnage",
        "twitchrivals"
    ],
    "channelUrls": [
        {
            "url": "https://www.twitch.tv/criticalrole/schedule"
        }
    ],
    "maxSegmentsPerChannel": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/twitch-channel-stream-schedule-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 = {
    "channelLogins": [
        "criticalrole",
        "cohhcarnage",
        "twitchrivals",
    ],
    "channelUrls": [{ "url": "https://www.twitch.tv/criticalrole/schedule" }],
    "maxSegmentsPerChannel": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/twitch-channel-stream-schedule-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channelLogins": [
    "criticalrole",
    "cohhcarnage",
    "twitchrivals"
  ],
  "channelUrls": [
    {
      "url": "https://www.twitch.tv/criticalrole/schedule"
    }
  ],
  "maxSegmentsPerChannel": 20
}' |
apify call automation-lab/twitch-channel-stream-schedule-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/twitch-channel-stream-schedule-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IglC2ffePXEPtDJfw/builds/ER33nbvzq1lP2YPYI/openapi.json