# YouTube Live Status Scraper & Viewer Count Monitor (`neverempty/youtube-live-status-monitor`) Actor

Check whether YouTube channels are live right now: concurrent viewer count, live video URL, title, start time and every scheduled stream. Turn monitoring on and a run returns a channel only when it goes live, ends a stream or schedules a new one, for a small fee per channel checked.

- **URL**: https://apify.com/neverempty/youtube-live-status-monitor.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.29 / 1,000 channel status row 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

## YouTube Live Status Scraper & Viewer Count Monitor - go-live alerts, priced per check

Check whether YouTube channels are live right now - **concurrent viewer count**, live video id and URL, title and start time - plus **every scheduled stream with its start time**. Give `@handle`s, channel ids or channel URLs; no API key and no YouTube quota are needed.

With monitoring on, **you receive a row only when something happens**: a channel goes live, ends its stream, starts another stream, or schedules a new one. A poll on which nothing changed returns a single free `no-change` row.

In monitoring mode you pay a small fee per channel checked, **$0.30 per 1,000 checks**, and the normal row price only for the rows that report a change. Watching 20 channels every 5 minutes is 172,800 checks a month, which is **$51.84** in check fees, plus the change rows you receive.

### Best for

- **Go-live alerts** - schedule a run every few minutes, send the dataset to Slack, Discord, Telegram or a webhook, and every row you receive is an event worth sending.
- **Upcoming-stream calendars** - collect every scheduled stream of a list of channels with its start time in UTC, and get a `scheduled` row as soon as a new one appears.
- **Sponsored-stream verification** - confirm that a paid creator actually went live, between which of your checks the stream ended, and the highest viewer count seen while you were watching.
- **24/7 and multi-stream channels** - channels that run several live streams at once (music, news, space agencies) list every one of them with its viewer count.
- **"Who is live now" lists** - check a roster once with `onlyLive` and receive only the channels that are live.

### What each row contains

- **What you asked for and what YouTube returned** - `inputChannel`, `channelId`, `channelHandle`, `channelName`, `channelUrl`, `channelMatchesInput`.
- **Live status** - `isLive`, `liveVideoId`, `liveVideoUrl`, `title`, `viewerCount`, `viewerCountIsRounded`, `startedAt`, `startedAtPrecision`, `liveDurationSeconds`, `category`, and `liveSeenOnStreamsTab` - whether the channel's Live tab also shows that stream with its LIVE badge, a second check of `isLive` from a different page.
- **Every live stream of the channel** - `liveStreamCount` and `liveStreams` (video id, URL, title, viewer count, and whether that count is rounded).
- **Scheduled streams** - `hasScheduledStream`, `nextScheduledVideoId`, `nextScheduledVideoUrl`, `nextScheduledTitle`, `nextScheduledStartTime`, `scheduledStreamCount` and `scheduledStreams` (video id, URL, title, start time in UTC, and how many people are waiting), earliest first. `allStreamsListed` says whether the channel's Live tab was read, so you know whether these lists are complete.
- **Monitoring** - `change`, `isFirstCheck`, `previousCheckedAt`, `previousIsLive`, `previousLiveVideoId`, `newLiveVideoIds`, `newScheduledVideoIds`, and for a stream that ended: `endedAfter`, `endedBefore`, `streamDurationSecondsAtLeast`, `streamDurationSecondsAtMost`, `peakViewerCountSeen`, `checksWhileLive`.

Measured on 2026-10-19 from Apify: Lofi Girl was live with `viewerCount` 2350 on its main stream and 23 live streams in total; NASA had 2 live streams and 2 scheduled streams, and a NASASpaceflight stream was scheduled for 09:30 UTC.

#### Viewer count

`viewerCount` is the **concurrent viewer count** YouTube shows on the live video ("2,350 watching"), not the video's total view count. For the stream YouTube shows on the channel's `/live` page it is the exact number. For the other streams of a channel that runs several at once, YouTube lists them with a shortened number ("2.3K watching"); those come back as `2300` with `viewerCountIsRounded: true`, so you always know which numbers are exact. YouTube does not publish a stream's peak, so `peakViewerCountSeen` is **the highest value your monitoring runs saw** while the stream was live.

#### Start time

`startedAtPrecision` tells you how exact `startedAt` is:

| `startedAtPrecision` | `startedAt` looks like | Where it comes from |
|---|---|---|
| `second` | `2026-10-19T14:11:05.000Z` | The stream's own start time, when YouTube includes it in the page. |
| `minute` / `hour` | `2026-10-19T14:11:00.000Z` | YouTube shows only "Started streaming 19 minutes ago" (or "3 hours ago"); the time is counted back from when the page was read. |
| `date` | `2026-10-01` | YouTube shows only "Started streaming on Oct 1, 2026". This is the date as YouTube writes it; YouTube does not say which time zone it uses. |
| `null` | `null` | The channel is not live, or no start was shown. |

From Apify's servers YouTube often withholds the video player of a stream that is live right now and shows the rest of the page - title, channel, the exact concurrent viewer count and the start line above. The Actor reads that same page; it does not log in or retry around it. On those pages `startedAt` is a date or a relative time, so **`liveDurationSeconds` is filled only when the precision is `second`**, and a monitoring `ended` row gives the duration range only when the start was known to the second; otherwise those fields are `null` rather than a guess.

#### Scheduled start times

The start time of the next scheduled stream comes from the video's own page, to the second, whenever YouTube shows that stream on the channel's `/live` page and includes its start time there; if the page leaves it out, the time from the channel's Live tab is used. The other scheduled streams come from the channel's Live tab, which shows the time to the minute in US Pacific time; it is converted to UTC with daylight saving time applied. The two are checked against each other on every channel that has both, and if they differ by more than a minute, the Live-tab times of that channel are returned empty instead of wrong.

### Monitoring, and what it costs

Turn **monitoring mode** on and the Actor remembers each channel's live streams and scheduled streams. On later runs a channel comes back only with one of these `change` values:

| `change` | Meaning |
|---|---|
| `first-check` | The channel had not been seen before. Every channel is returned once on the first run, to set the baseline. |
| `went-live` | Not live at the previous run, live now. |
| `ended` | Live at the previous run, not live now. The row says the stream ended between `endedAfter` (the previous run) and `endedBefore` (this run), gives the duration as a range (`streamDurationSecondsAtLeast` to `streamDurationSecondsAtMost`) when the start was known to the second, and the highest viewer count seen by your runs while it was live. |
| `new-stream` | Live at both runs, and a stream is live now that was not live at the previous run (a new stream replaced the old one, or a second one started). `newLiveVideoIds` lists them. |
| `scheduled` | The live status did not change, but a stream was scheduled that the previous run did not see. `newScheduledVideoIds` lists them. |

A channel whose status did not change is **not returned**, so it costs no row price; the check fee for reading it still applies. A scheduled stream that disappears without going live is not reported as a change.

The duration of a stream is a range, not a single number, because the Actor only knows the status at the moments it runs. Run it more often for a narrower range.

The status is remembered **per channel, not per list**, so adding a channel does not reset the channels already being watched. In monitoring mode `maxChannels` does not cut changes: every change among the channels read is returned. If the run's maximum total charge stops a change from being delivered, that change is not remembered, so the channel still counts as changed the next time it is checked.

**Do not put the same channel in two schedules that can run at the same time.** Each run writes back only the channels it checked, merged into the statuses as they are at that moment, then reads them again and writes once more if another run overwrote them - so two overlapping runs over different channels keep each other's history. But Apify's key-value store has no atomic update, so this cannot be made watertight: runs that finish at the same instant, or check the same channel at the same time, can still overwrite each other's record, and the next run may return a `first-check` or a change a second time.

#### What monitoring costs

- **$0.30 per 1,000 channel checks** - charged in monitoring mode for every channel whose status was read, whether or not it changed. Channels YouTube answers "not found" for and bot checks are not charged.
- **The row price** - charged only for the rows returned, which in monitoring mode means `first-check` rows and changes.

The Actor reads only as many channels as the run's maximum total charge can pay for with both a check and a change row each, so a low limit cannot use up the budget on check fees and leave nothing for the rows. Channels beyond that are not checked; a `budget-reached` row says how many, and raising the maximum total charge lets them be checked. Runs with monitoring off are charged per row only.

### Rows that are never charged

When there is nothing to return, this Actor says why instead of returning an empty result:

- `no-such-channel` - YouTube answered "not found" for that handle or URL. A handle that does not exist gets this answer; whether a terminated channel gets the same answer has not been measured, so the row does not claim which.
- `blocked` - YouTube answered with a bot check, a consent page, a rate limit or an empty response. The channel is not reported as offline. Requests go out directly first, and only this answer makes the run switch to a proxy session and try again.
- `unreadable` - the page could not be read in the shape this Actor knows, or the channel's Live tab could not be read (a row without it could later report a stream as new when it is not).
- `other-channel` - the live stream YouTube returned belongs to a different channel than the one asked for.
- `duplicate` - the same channel was given twice in different forms (for example its `@handle` and its channel id); it is returned and charged once.
- `no-change` - monitoring ran and no channel changed. The row lists the channels that are still live.
- `no-match` - `onlyLive` is on and none of the channels is live right now.
- `invalid-input` - the text is not a YouTube channel: a video link, a playlist, a search or another site. Nothing was requested for it.
- `budget-reached` - the run's maximum charge was reached: the row says how many ready rows fit, or how many channels were not checked in monitoring mode.
- `not-checked` - some channels were not checked or not returned, because `maxChannels` had already been reached (monitoring off), or because more than 1,000 channels were given. The row says how many.

### How fast

Three channels are read at a time, with a short pause between groups. A channel that is not live takes one page; a live channel, or one with a stream scheduled, takes two (its `/live` page and its Live tab), or one with `includeAllStreams` off.

### Input

| Field | What it does |
|---|---|
| `channels` | The channels to check: `@handle`, channel id (`UC...`), or a channel URL. `@LofiGirl` and `@lofigirl` are the same channel and are checked once. If empty, the example channels @LofiGirl and @NASA are checked. |
| `maxChannels` | How many charged rows to return in total (up to 1,000). |
| `onlyLive` | Return only the channels that are live right now. |
| `includeAllStreams` | Also read the channel's Live tab, so every live stream and every scheduled stream is listed. On by default. |
| `monitoringMode` | Remember the status and return a channel only when it changes. |
| `resetMonitoringState` | Forget every remembered status and start a fresh baseline. |
| `useProxy` | Retry through a proxy if YouTube answers with a bot check or a rate limit. Every request goes out directly first. |

### Questions

**How do I get an alert when a YouTube channel goes live?**
Turn on `monitoringMode`, schedule the Actor, and send the run's dataset to your channel with an Apify integration or webhook. How often is a trade-off between how fast you hear about a stream and the check fee: 20 channels every 5 minutes is 172,800 checks a month ($51.84); every 15 minutes is 57,600 ($17.28). Rows with `change: "went-live"` are go-live events; `ended` rows tell you the stream is over; `scheduled` rows announce an upcoming stream.

**How do I get the current viewer count of a YouTube live stream?**
Put the channel in `channels` and run the Actor. `viewerCount` is the number of people watching right now, and `liveStreams` gives the count for every stream if the channel runs several.

**Does monitoring charge me when nothing changed?**
Unchanged channels are not returned and cost no row price. Each channel checked costs the check fee ($0.30 per 1,000), changed or not - that is what pays for polling.

**Why is `startedAt` sometimes only a date?**
When YouTube shows a live stream's page without the video player, the page says only "Started streaming on Oct 1, 2026" or "Started streaming 19 minutes ago". The row returns exactly that much, with `startedAtPrecision` set to `date`, `minute` or `hour`, and leaves `liveDurationSeconds` empty instead of inventing a time of day. `isLive` and `viewerCount` are read the same way on both kinds of page.

**Do I need a YouTube API key?**
No. The Actor reads the public channel pages, with no login, no API key and no daily quota.

### Good to know

- The data comes from YouTube's public channel pages (the `/live` page and the Live tab), read without a login. They are not YouTube's documented Data API, so **YouTube can change them without notice**; if a page changes shape, runs return free `unreadable` rows instead of guessing.
- A stream that starts and ends entirely between two monitoring runs is not seen. Run more often if short streams matter to you.
- Only the first page of a channel's Live tab is read - the part YouTube shows before you scroll. Live and scheduled streams appear there; very old ones do not matter for live status.
- `category` is filled only for the stream shown on the channel's `/live` page, and only when YouTube includes the video player there; otherwise it is `null`.
- `startedAt` is exact to the second only when `startedAtPrecision` is `second`. A `date` value is the date YouTube writes on the page, in a time zone YouTube does not state.
- With `includeAllStreams` off, only the stream YouTube shows on the channel's `/live` page is known. In monitoring mode a channel running several streams at once can then be reported as `new-stream` when YouTube shows a different one of them.
- The Actor reports status and counts. It does not record or download streams and does not read the chat.

### Example input

```json
{
  "channels": ["@LofiGirl", "@NASA", "https://www.youtube.com/@NASASpaceflight"],
  "monitoringMode": true,
  "onlyLive": false,
  "maxChannels": 100
}
```

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

Channels to check: @handle, channel id (UC...), or a channel URL (https://www.youtube.com/@handle, /channel/UC..., /c/name or /user/name, with or without the scheme). A plain name is read as @name. Video links are not channels and come back as a free row. The same channel written twice is checked once. Up to 1,000 per run. If you leave this empty, the example channels @LofiGirl and @NASA are checked and every row says so in inputChannel.

## `maxChannels` (type: `integer`):

How many charged rows to return in total when monitoring is off: reading stops once this many channels have been read (with onlyLive, once this many live channels have been found), and a free row says how many were not checked or not returned. In monitoring mode it does not limit the changes returned - every change among the channels read comes back.

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

On = channels that are not live are checked but not returned, so they cost no row price (in monitoring mode the check fee still applies). Handy for a 'who is live now' list.

## `includeAllStreams` (type: `boolean`):

On = the channel's Live tab is read as well, so a channel running several streams at once lists all of them (with their viewer counts) and every scheduled stream with its start time. When the channel is live this reads one more page per channel. Off = only the stream YouTube shows on the channel's /live page is reported; in monitoring mode, a channel with several streams at once can then be reported as a new stream when YouTube shows a different one of them.

## `monitoringMode` (type: `boolean`):

Off = every channel you listed comes back with its current status, charged per row. On = the Actor remembers each channel and, on later runs, returns it only when it went live, ended its stream, started another stream, or scheduled a new stream. The first run returns every channel once to set the baseline. **In monitoring mode every channel checked is charged as a check, changed or not** (channels YouTube answers 'not found' for and bot checks are free), plus the row price for the rows returned. The check fee is $0.30 per 1,000 checks: 20 channels every 5 minutes = 172,800 checks a month = $51.84. The Actor reads only as many channels as the run's maximum total charge can pay for with a check and a change row each. The status is remembered per channel; do not put the same channel in two schedules that can run at the same time.

## `resetMonitoringState` (type: `boolean`):

Clears every remembered live status for this Actor, so the next monitoring run returns each channel once again. This affects all your monitoring runs, because the status is stored per channel rather than per list.

## `useProxy` (type: `boolean`):

Every request goes out directly first, which worked from Apify on every attempt measured on 2026-10-19. If YouTube answers with a bot check, a consent page, a rate limit or an empty response, this switches to a proxy session and tries again. With it off, that answer is returned as a free 'blocked' row and no proxy is paid for.

## Actor input object example

```json
{
  "channels": [
    "@LofiGirl",
    "@NASA"
  ],
  "maxChannels": 100,
  "onlyLive": false,
  "includeAllStreams": true,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "useProxy": true
}
```

# Actor output Schema

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

One row per YouTube channel: the channel you asked for and the one YouTube returned (id, handle, name, URL), whether it is live right now, and for live channels the live video id and URL, title, concurrent viewer count, start time, how long it has been live and category, plus every live stream of the channel with its viewer count; every scheduled stream with its start time in UTC; and, in monitoring mode, what changed since the last run (went live, ended, new stream, or newly scheduled) with the bounds of an ended stream's duration and the highest viewer count seen. Handles YouTube answers 'not found' for and bot checks come back as their own free rows; in monitoring mode unchanged channels are not returned.

# 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": [
        "@LofiGirl",
        "@NASA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/youtube-live-status-monitor").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": [
        "@LofiGirl",
        "@NASA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/youtube-live-status-monitor").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": [
    "@LofiGirl",
    "@NASA"
  ]
}' |
apify call neverempty/youtube-live-status-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/youtube-live-status-monitor"
        }
    }
}
```

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/7fxZZGIQy4zIvkA3O/builds/pmYdFBbCl4M9HQ267/openapi.json