# YouTube Channel Live Scraper (`socialdataapi/youtube-channel-live-scraper`) Actor

YouTube Channel Live Scraper scrapes every live, upcoming and past stream from YouTube channels' Live tab: title, video ID, URL, thumbnail, view count, duration, scheduled or streamed time, status and channel info. No login. Export JSON, CSV or Excel, or use the API.

- **URL**: https://apify.com/socialdataapi/youtube-channel-live-scraper.md
- **Developed by:** [Social Data API](https://apify.com/socialdataapi) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.67 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### YouTube Channel Live Scraper — Live, Upcoming and Past Streams

YouTube Channel Live Scraper reads a channel's Live tab and returns every stream listed there: title, video ID, URL, thumbnail, view count, duration, scheduled or streamed time, and a live/upcoming/past status, plus the channel's own ID, name, handle and avatar. Every response is structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a social-monitoring pipeline. No YouTube account or cookies needed. Start with one channel, then add as many as you track.

***

### What data can I extract with YouTube Channel Live Scraper?

Using this YouTube Channel Live API, you will be able to extract the following YouTube channel Live-tab data:

| 🎬 Title | 🆔 Video ID | 🔗 Video URL | 🖼️ Thumbnail |
|---|---|---|---|
| 🔴 Live/upcoming/past status | 👁️ View count | ⏱️ Duration | 📅 Published / scheduled time |
| 🏷️ Channel ID | 📛 Channel name | 👤 Channel handle | 🖼️ Channel avatar |
| 🔗 Channel URL | #️⃣ Position in list | 🎫 Extra badges (e.g. 4K) | |

***

### How to use YouTube Channel Live Scraper

Anyone tracking a creator's livestream schedule — a fan dashboard, a stream-alert bot, a social-media report — gets a full, current list of a channel's streams from one run.

**Copy to your AI assistant:**

```text
socialdataapi/youtube-channel-live-scraper is an Apify Actor that returns a YouTube channel's Live-tab streams as structured JSON: title, video ID, URL, thumbnail, view count, duration, streamed/scheduled time and live/upcoming/past status, plus channel ID, name, handle and avatar. Use it whenever someone needs a channel's live schedule without cookies, a login, or a browser - a stream-alert bot, a fan dashboard, or a social-listening report. Run it with curl: curl -X POST "https://api.apify.com/v2/acts/socialdataapi~youtube-channel-live-scraper/run-sync-get-dataset-items?token=APIFY_TOKEN" -H "Content-Type: application/json" -d '{"channels": ["@IShowSpeed"], "maxItems": 20}'. Or in Python: ApifyClient("APIFY_TOKEN").actor("socialdataapi/youtube-channel-live-scraper").call(run_input={"channels": ["@IShowSpeed"], "maxItems": 20}) then client.dataset(run["defaultDatasetId"]).list_items().items. Inputs: channels (array of strings, one or more channel handles/URLs/IDs, required), maxItems (integer, max streams PER channel, default 20, 0 = all), statuses (array, subset of "live"|"upcoming"|"past", default: no filter), language (string, UI language code, default "en"), country (string, region code, default "US"), continuationToken (string, resume a single-channel run), proxyConfiguration (optional). Full input schema, every enum and default, and the complete output field list: GET https://api.apify.com/v2/acts/socialdataapi~youtube-channel-live-scraper/builds/default
```

#### YouTube Channel Live Scraper MCP Server: use these Actors from ChatGPT, Claude or Cursor

Point your AI assistant at Scrapier and it can read YouTube on its own: channel streams, videos, Shorts and thumbnails. No glue code, no scraping logic in your prompts.

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=socialdataapi/youtube-channel-live-scraper"
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open [YouTube Channel Live Scraper](https://apify.com/socialdataapi/youtube-channel-live-scraper) in the Apify Store.
3. Enter the YouTube channel handle, ID or URL.
4. Click **Start**.
5. Download or stream your results in JSON, CSV or Excel.

#### How to scale YouTube Channel Live Scraper to bulk

Add more entries to `channels` — each one is scraped on its own and gets its own `maxItems` streams, so 10 channels at `maxItems: 20` return up to 200 rows in one run. For a channel with more streams than fit in one run, read the `continuationToken` the run leaves in its status message and pass it back in on the next run (single-channel runs only).

***

### ✨ Features

YouTube Channel Live Scraper fetches clean, structured streams from a channel's Live tab ⚡ at low cost 💸. It's ideal for stream-alert bots, fan/creator dashboards, social-listening reports, and feeding an AI agent a channel's current schedule.

It extracts, per stream:

- **Title** – the stream's headline.
- **Live/upcoming/past status** – where the stream is in its lifecycle.
- **View count** – watching/waiting/viewed count, as text and as a number.
- **Duration** – for streams that already ended.
- **Published/scheduled time** – both the site's own text and a parsed ISO timestamp.
- **Channel info** – ID, name, handle, avatar and URL on every row.

⚡ Multiple channels run at the same time, and results are saved to the dataset as soon as each page is read — no waiting for the whole run to finish before seeing rows.

***

### Use cases 💡

- **Stream-alert bot** — poll a channel's `streamStatus` and notify followers the moment it flips to "live".
- **Creator-ops dashboard** — track upcoming scheduled streams and past stream view counts across a roster of channels.
- **Social-listening analyst** — pull view-count trends for a competitor's live content over time.
- **AI agent builder** — feed a channel's current Live-tab schedule straight into an agent's context, no parsing step.

Building an AI agent? [Connect YouTube Channel Live Scraper over MCP](#youtube-channel-live-scraper-mcp-server-use-these-actors-from-chatgpt-claude-or-cursor) and let it call the actor on its own.

***

### Why choose this actor?

1. **Multi-channel in one run.** List any number of channels and each one gets its own `maxItems` cap — no shared counter that lets one channel use up another's rows.
2. **A full status filter.** Narrow results to only `live`, only `upcoming`, only `past`, or any mix, instead of pulling the whole tab every time.
3. **Resume where you left off.** A single-channel run that stops early hands back a token to continue the same listing on the next run, instead of re-reading pages you already have.

***

### ⬇️ Input

Give the actor one or more YouTube channels (`channels`, required); every other field is optional.

| Parameter | Required | Type | Description | Example value |
|---|---|---|---|---|
| `channels` | Yes | array of strings | Channel handle (`@name`), bare channel ID, or full channel URL. One or more; each gets its own `maxItems`. | `["@IShowSpeed"]` |
| `maxItems` | No | integer | Max streams to collect per channel. Default 20, 0 = every stream on the channel. | `20` |
| `statuses` | No | array of strings | Subset of `"live"`, `"upcoming"`, `"past"`. Default: no filter (all statuses). | `["live", "upcoming"]` |
| `language` | No | string | YouTube UI language code. Default `"en"`. | `"en"` |
| `country` | No | string | YouTube region code. Default `"US"`. | `"US"` |
| `continuationToken` | No | string | Resume a previous single-channel run's listing from this token. | `""` |
| `proxyConfiguration` | No | object | Optional starting proxy; the actor escalates automatically if blocked. | `{"useApifyProxy": false}` |

#### Free plan limits

Free plan: up to 20 streams per run (all channels together) and 200 per month; paid plans have no limit.

#### Example input

```json
{
  "channels": ["@IShowSpeed", "UCWsDFcIhY2DBi3GB5uykGXA"],
  "maxItems": 20,
  "statuses": [],
  "language": "en",
  "country": "US",
  "continuationToken": "",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

***

### ⬆️ Output

Every stream is one typed, normalized JSON item with the same schema on every run. Export it as JSON, CSV or Excel.

#### Example output

```json
{
  "type": "live",
  "status": "ok",
  "streamStatus": "past",
  "position": 1,
  "id": "aBcDeFgHiJk",
  "url": "https://www.youtube.com/watch?v=aBcDeFgHiJk",
  "title": "LIVE: Reacting to the new update",
  "thumbnail": "https://i.ytimg.com/vi/aBcDeFgHiJk/hq720.jpg",
  "channelId": "UCWsDFcIhY2DBi3GB5uykGXA",
  "channelName": "IShowSpeed",
  "channelHandle": "@IShowSpeed",
  "channelThumbnail": "https://yt3.ggpht.com/abc123",
  "channelUrl": "https://www.youtube.com/channel/UCWsDFcIhY2DBi3GB5uykGXA",
  "viewCountText": "2M views",
  "viewCountInt": 2000000,
  "publishedTimeText": "Streamed 14 hours ago",
  "publishedTime": "2026-11-13T21:04:12.000Z",
  "lengthText": "2:43:42",
  "lengthSeconds": 9822,
  "badges": [],
  "scrapedAt": "2026-11-14T16:02:33.102Z"
}
```

***

### How does it work?

YouTube Channel Live Scraper reads the same public Live-tab data any visitor sees on a channel's page, without needing a YouTube account. It retries and switches to a proxy automatically if YouTube blocks a request, so you don't manage proxy accounts yourself. Only publicly visible stream data is returned — no viewer or chat data, matching what the tab itself shows a logged-out visitor. The output schema is normalized and stays stable even when YouTube changes how its own page looks.

***

### How do you integrate YouTube Channel Live Scraper into your stack?

It works with what you already use: a REST API from any language, MCP for AI agents, or a no-code tool.

#### Using YouTube Channel Live Scraper with the Apify API

```python
import requests

resp = requests.post(
    "https://api.apify.com/v2/acts/socialdataapi~youtube-channel-live-scraper/run-sync-get-dataset-items",
    params={"token": "APIFY_TOKEN"},
    json={"channels": ["@IShowSpeed"], "maxItems": 20},
)
for item in resp.json():
    print(item["title"], item["streamStatus"])
```

*Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.*

#### MCP integration for AI agents

Registering the actor over MCP lets Claude Code, Cursor or Windsurf call it directly as a tool, with no glue code in your prompts.

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=socialdataapi/youtube-channel-live-scraper"
```

#### No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node's "Run an Actor" action, or the HTTP Request node pointed at the run-sync endpoint with your token. In Make, use the Apify app's "Run an Actor" module followed by "Get Dataset Items". In LangChain, install `langchain-apify` and call `ApifyActorsTool("socialdataapi/youtube-channel-live-scraper")`.

***

### Is it legal to scrape YouTube channel data?

Scraping publicly available web data, including a channel's public Live-tab listing, is generally considered legal. YouTube Channel Live Scraper returns only publicly available data — what any visitor sees without logging in. Under GDPR, scraping public data is generally permissible, but storing and using it must still comply with local data-protection law. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does YouTube Channel Live Scraper return?

Title, video ID, video URL, thumbnail, live/upcoming/past status and view count, plus channel ID, name and URL. See [the data fields section](#what-data-can-i-extract-with-youtube-channel-live-scraper).

#### Does YouTube Channel Live Scraper require a YouTube account or login?

No. Only public Live-tab data is extracted; no credentials are needed.

#### What happens if a channel is private, blocked or has no Live tab?

That channel is skipped (not charged) and the run continues with the others; the run's log and status message say which channels could not be read.

#### Can I scrape multiple YouTube channels at once?

Yes. Add every channel handle, ID or URL to the `channels` array; each one gets its own `maxItems` streams in the same run.

#### Does YouTube Channel Live Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes — it is available as an MCP tool. Use the command above to register it in Claude Code, Cursor or Windsurf. Any agent that can call an HTTP endpoint can use the REST API directly.

#### Does YouTube Channel Live Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names — no HTML parsing, no selectors. Pass it straight to an LLM, index it into a vector store, or feed it to an agent tool.

#### What happens when YouTube changes its layout?

Scrapier maintains the actor. When YouTube changes, Scrapier updates the actor — your calls keep returning the same JSON schema with no changes on your end.

#### Can I use YouTube Channel Live Scraper without managing proxies myself?

Yes. Proxy escalation runs on the actor's side if YouTube blocks a request. You send one request and get structured JSON back.

***

### Your feedback

Found a bug or missing a field? Let us know through the actor's Issues tab on Apify Store. The Scrapier team reads every report and ships fixes.

# Actor input Schema

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

One or more YouTube channels: a handle (e.g. '@IShowSpeed'), a bare channel ID ('UCxxxxxxxxxxxxxxxxxxxxxx'), or a full channel URL (with or without a tab). Each channel is scraped on its own and gets its own 'Max streams per channel'.

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

Maximum number of streams to collect for EACH channel (3 channels x 20 = up to 60 streams). A channel stops earlier once its own Live tab ends. 0 = every stream on the channel. Free plan: up to 20 streams per run (all channels together) and 200 per month; paid plans have no limit.

## `statuses` (type: `array`):

Only count streams in these statuses toward 'Max streams per channel'. Leave empty to collect every status.

## `language` (type: `string`):

YouTube UI language code (e.g. 'en', 'es', 'ja') used to resolve the channel and read its Live tab. Note: view-count and published-time text fields are parsed with English-only patterns, so they may come back empty for a non-English language.

## `country` (type: `string`):

YouTube region code (e.g. 'US', 'GB', 'JP') used to resolve the channel and read its Live tab.

## `continuationToken` (type: `string`):

Resume a previous single-channel run's listing from this token instead of starting from the first page (only used when exactly one channel is given).

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

Optional proxy to start with. If YouTube blocks requests, the actor moves to a stronger proxy automatically.

## Actor input object example

```json
{
  "channels": [
    "@IShowSpeed"
  ],
  "maxItems": 20,
  "statuses": [],
  "language": "en",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `stats` (type: `string`):

No description

## `channel` (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": [
        "@IShowSpeed"
    ],
    "maxItems": 20,
    "language": "en",
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("socialdataapi/youtube-channel-live-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 = {
    "channels": ["@IShowSpeed"],
    "maxItems": 20,
    "language": "en",
    "country": "US",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("socialdataapi/youtube-channel-live-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 '{
  "channels": [
    "@IShowSpeed"
  ],
  "maxItems": 20,
  "language": "en",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call socialdataapi/youtube-channel-live-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,socialdataapi/youtube-channel-live-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/uB4wBbmfvqt0dbgFo/builds/HjPacI7yh0q67Bl6S/openapi.json
