# YouTube Breakout Alerts (`ecru_manor/youtube-breakout-alerts`) Actor

Get alerted when a YouTube video takes off. Compares each video with the channel's usual views at the same age, explains how it's doing in plain English, and sends alerts to Slack or Discord. No API key needed.

- **URL**: https://apify.com/ecru_manor/youtube-breakout-alerts.md
- **Developed by:** [Arnoid](https://apify.com/ecru_manor) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.00 / 1,000 channel checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Breakout Alerts

Find out when a YouTube video takes off, while there's still time to act on it. Add the channels you follow, schedule the Actor, and get a Slack or Discord message that explains what's happening.

No YouTube API key, no login and no setup beyond pasting your channels.

### Why use this Actor?

- **Fair comparisons.** A 12-hour-old video is compared with what that channel's videos usually have at about 12 hours, not with their lifetime totals. Shorts are compared only with Shorts.
- **Useful from the first run.** Scores start right away using an estimate, and improve as the Actor measures a channel over time.
- **Alerts built in.** Send to Slack or Discord without another automation tool. Each video alerts once.
- **Plain-English results.** Every video comes with a sentence explaining how it's doing.
- **No surprise charges.** You pay per channel successfully checked. Alerts, test alerts, skipped channels, duplicates and accidental re-runs within 30 minutes have no channel charge, and runs stop at your spending limit.
- **A visual report.** Every run creates a page of video cards, with breakouts at the top.

### Who is it for?

- **YouTube creators** spotting what's working in their niche
- **Marketing teams** tracking competitors
- **Agencies** watching channels for several clients, with one watchlist each
- **Sponsorship teams** finding creators who are gaining momentum

### How to use it

1. Add your channels as links, @handles or channel IDs.
2. Optional: paste a Discord or Slack webhook URL, turn on **Send a test alert**, and run once to check it. Then turn the test off.
3. Click **Schedule** and choose how often to check. Every 6 hours suits most channels, and once a day costs the least. See Pricing below before you choose.

Keep **Watchlist name** the same between runs, because that's where history is saved.

### Pricing

This Actor charges per channel successfully checked, plus a very small fee each time a run starts. Platform usage is included. See the Pricing tab for the current rates. Your cost depends mostly on how often you check, so choose your schedule first. Here's what 20 channels would cost at $0.011 per channel:

| Schedule | Checks a month | Approximate cost a month |
|---|---:|---:|
| Once a day | 600 | $6.60 |
| Every 6 hours | 2,400 | $26.40 |
| Every hour | 14,400 | $158.40 |

Prices can change, so check the Pricing tab for the current rate. For most channels, checking more than every 6 hours adds cost without adding much. To estimate your own usage, multiply channels × runs per day × 30.

### Output

Example values:

```json
{
  "title": "Example video",
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "channelTitle": "Example channel",
  "format": "long",
  "isBreakout": true,
  "why": "Taking off! It has 200K views after 42 hours. This channel's videos usually have about 50K by this age, so this one is at 4 times the usual. It's gaining about 2.1K views an hour right now.",
  "score": 4,
  "views": 200000,
  "expectedViews": 50000,
  "viewsPerHour": 2100,
  "velocitySource": "measured",
  "baselineSource": "age-curve",
  "ageHours": 42,
  "likes": 9000,
  "likeRate": 4.5,
  "publishedAt": "2026-11-03T14:00:00+00:00"
}
```

Export as JSON, CSV or Excel, or use the Apify API. Each run's log and Output tab also link to the visual report.

### How the score works

`score` is the video's views divided by the views expected at its age. A video is a breakout when it reaches your threshold, is at most 7 days old, and has at least your minimum views.

- **`age-curve`:** an estimate from the channel's videos over a week old, adjusted for age with a square-root curve. It's a rule of thumb, not YouTube data.
- **`tracked-peers`:** what at least 5 earlier videos really had at this age, measured by this Actor over time. It takes a while to build up.
- **`none`:** there aren't enough earlier videos in that format to compare with.

Videos under 2 hours old aren't scored.

### Limitations

- Data comes from YouTube's public channel feeds, which list each channel's **latest 15 uploads**. A channel posting more than that between runs will have some missed.
- Channels that mix formats may have too few long-form videos or Shorts in those 15 to score both.
- YouTube doesn't update feed counts constantly, so `viewsPerHour` can show 0 when runs are close together. Runs a few hours apart work better.
- A score is a signal, not a guarantee.
- This Actor reads public video statistics only. It doesn't collect comments, emails or viewer data. You're responsible for using the results in line with the terms and laws that apply to you. It isn't affiliated with or endorsed by YouTube.

### FAQ

**Why did I get no alerts?** Most runs find no breakouts, which is normal. Lower the threshold if you want more.

**Something's wrong?** Open an issue on the Issues tab with your run link.

# Actor input Schema

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

Channels to watch. Paste a channel link, an @handle or a channel ID.

## `breakoutMultiple` (type: `number`):

Flag a video when it has this many times the views expected at its age. 2 means twice the usual.

## `minViews` (type: `integer`):

Ignore videos below this view count, which filters out noise on small channels.

## `onlyBreakouts` (type: `boolean`):

Turn on to leave out every video that isn't a breakout. The report still shows them all.

## `discordWebhookUrl` (type: `string`):

Starts with https://discord.com/api/webhooks/

## `slackWebhookUrl` (type: `string`):

Starts with https://hooks.slack.com/

## `maxAlertsPerRun` (type: `integer`):

Highest scores go first. Any extras are sent on the next run.

## `sendTestAlert` (type: `boolean`):

Sends one labelled sample so you can check your webhook. Turn this off before scheduling.

## `minMinutesBetweenChecks` (type: `integer`):

Channels checked more recently than this are skipped at no charge, which protects you from paying twice for an accidental re-run. Set to 0 to turn this off.

## `watchlistName` (type: `string`):

History is saved under this name between runs. Use a different name for each separate list of channels.

## Actor input object example

```json
{
  "channels": [
    "https://www.youtube.com/@mkbhd",
    "@veritasium"
  ],
  "breakoutMultiple": 2,
  "minViews": 1000,
  "onlyBreakouts": false,
  "maxAlertsPerRun": 10,
  "sendTestAlert": false,
  "minMinutesBetweenChecks": 30,
  "watchlistName": "default"
}
```

# Actor output Schema

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

No description

## `report` (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": [
        "https://www.youtube.com/@mkbhd",
        "@veritasium"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecru_manor/youtube-breakout-alerts").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": [
        "https://www.youtube.com/@mkbhd",
        "@veritasium",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ecru_manor/youtube-breakout-alerts").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": [
    "https://www.youtube.com/@mkbhd",
    "@veritasium"
  ]
}' |
apify call ecru_manor/youtube-breakout-alerts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ecru_manor/youtube-breakout-alerts"
        }
    }
}
```

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/u5Tv6FgXJGlZvpVSj/builds/u93PT0kXrfvyZ1Tug/openapi.json