# 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 `riotgames`, `hasanabi`, or `criticalrole`.

```json
{"channelLogins":["riotgames","hasanabi"],"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/riotgames/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 | Estimated 20-segment run\* |
| --- | ---: | ---: |
| 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: ['riotgames'], 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':['riotgames'], '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":["riotgames"],"maxSegmentsPerChannel":20}'
```

### MCP

Use this actor from Claude Code or Claude Desktop through Apify MCP. Add it to Claude Code with:

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

For a desktop MCP configuration, use:

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

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 riotgames. 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": [
    "riotgames"
  ],
  "channelUrls": [
    {
      "url": "https://www.twitch.tv/riotgames/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": [
        "riotgames"
    ],
    "channelUrls": [
        {
            "url": "https://www.twitch.tv/riotgames/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": ["riotgames"],
    "channelUrls": [{ "url": "https://www.twitch.tv/riotgames/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": [
    "riotgames"
  ],
  "channelUrls": [
    {
      "url": "https://www.twitch.tv/riotgames/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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Channel Stream Schedule Scraper",
        "description": "Export public Twitch stream schedules for creator campaigns, partnership planning, and channel availability monitoring.",
        "version": "0.1",
        "x-build-id": "7eD72xZvIOijHPQ57"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~twitch-channel-stream-schedule-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-twitch-channel-stream-schedule-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~twitch-channel-stream-schedule-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-twitch-channel-stream-schedule-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~twitch-channel-stream-schedule-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-twitch-channel-stream-schedule-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "channelLogins": {
                        "title": "👤 Channel logins",
                        "type": "array",
                        "description": "Twitch login names, for example riotgames. Use this or channel URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channelUrls": {
                        "title": "🔗 Channel URLs",
                        "type": "array",
                        "description": "Twitch channel or /schedule URLs. Logins and URLs can be combined.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxSegmentsPerChannel": {
                        "title": "Maximum schedule segments per channel",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Caps exported upcoming public segments per channel.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```