# YouTube Viral Moment Finder — Heatmap, Transcript (`vanborn_labs/youtube-viral-moments-finder`) Actor

Find the best clip timestamps in long YouTube videos and podcasts using the Most Replayed heatmap, the transcript and timestamp mentions in comments. Ranked moments with start/end times and quotes. No login, no API key. $6 per 1,000 analysed videos; failed videos are free.

- **URL**: https://apify.com/vanborn_labs/youtube-viral-moments-finder.md
- **Developed by:** [Van Born Labs](https://apify.com/vanborn_labs) (community)
- **Categories:** Videos, Social media, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 analysed videos

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 Viral Moment Finder — Heatmap, Transcript

**YouTube Viral Moment Finder** tells you where to cut. For each long YouTube video or podcast it combines three signals: the **Most Replayed heatmap**, the **transcript** and **timestamps viewers mention in comments**. It then returns ranked clip moments with start and end times, a ready clip URL, the transcript quote and why the moment scored.

Built for clippers, podcast editors and social teams who turn long videos into Shorts, TikToks and Reels. One price per analysed video covers every moment found.

### What is YouTube Viral Moment Finder?

YouTube Viral Moment Finder is an Apify Actor by Van Born Labs. It runs in the cloud, so you can start it from the Apify Console, call it through the Apify API, schedule it, or plug it into Make, n8n, Zapier, Google Sheets and AI agents through the Apify MCP server. Results can be exported as JSON, CSV, Excel, XML or HTML.

#### Key features

- Takes one or more YouTube video or podcast URLs.
- Reads the public Most Replayed heatmap (when YouTube publishes one).
- Pulls a timed transcript when captions exist.
- Scans comments for timestamps and clusters the mentions.
- Merges those signals into ranked **moments**, each with a start/end time, a 25-second suggested clip window, a score, a short transcript excerpt and sample comments.
- Failed or private videos are not charged.

### What data can YouTube Viral Moment Finder extract?

| Field | What it means |
|---|---|
| `videoId` | Video ID |
| `url` | URL |
| `title` | Title |
| `durationSeconds` | Duration |
| `transcriptAvailable` | Transcript available |
| `heatmapBinCount` | Heatmap bins |
| `commentsScanned` | Comments scanned |
| `momentCount` | Moments |
| `moments` | Moments |
| `error` | Error |

### How to use YouTube Viral Moment Finder

1. Open the Actor and click **Try for free** (an Apify account is free and includes monthly platform credit).
2. Paste long YouTube video or podcast URLs, then set clip length and how many moments you want.
3. Click **Start** and wait for the run to finish. Small runs finish in seconds.
4. Download the results as JSON, CSV or Excel, or connect them to your app with the Apify API, a webhook or an integration.
5. To monitor changes, save your input as a task and add a **schedule** (hourly, daily or weekly).

### How much does it cost to use YouTube Viral Moment Finder?

This Actor uses **pay-per-event** pricing: **$6.00 per 1,000 analysed videos** plus a tiny $0.00005 start fee per run. You only pay for analysed videos actually returned; failed lookups are not charged. Platform usage is included in the price.

| Analysed videos | Price |
|---|---|
| 100 | $0.60 |
| 1,000 | $6.00 |
| 10,000 | $60.00 |

Apify's free plan includes $5 of monthly credit, which covers about **833 analysed videos** with this Actor. Set **Max cost per run** in the run options if you want a hard spending cap.

### Use cases

- **Clippers**: jump to the peaks of a two-hour podcast instead of watching the whole thing.
- **Editors**: export a list of candidate in/out points with context.
- **Agencies**: batch a week's worth of source videos and pick the strongest hooks.

### Input

Full field descriptions are on the **Input** tab. Example input (this is also the default run, which finishes in under a minute):

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
  ],
  "maxMoments": 8,
  "maxComments": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output

Each result is one row in the dataset. Example output item from a real run:

```json
{
  "input": "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
  "videoId": "UF8uR6Z6KLc",
  "url": "https://www.youtube.com/watch?v=UF8uR6Z6KLc",
  "title": null,
  "channelName": null,
  "durationSeconds": null,
  "transcriptAvailable": false,
  "transcriptError": "BOT_CHECK",
  "heatmapBinCount": 100,
  "commentsScanned": 50,
  "momentCount": 8,
  "moments": [
    {
      "startSeconds": 338,
      "endSeconds": 363,
      "startLabel": "5:38",
      "endLabel": "6:03",
      "score": 0.686,
      "heatmapIntensity": 0.7021,
      "commentMentions": 1,
      "reasons": [
        "most replayed (intensity 0.70)",
        "1 comment timestamp mention(s)"
      ],
      "sources": [
        "comments",
        "heatmap"
      ],
      "transcriptExcerpt": null,
      "commentQuotes": [
        "0:55 - Connecting the Dots\r\n5:38 - Love and Loss\r\n9:04 - Death"
      ],
      "watchUrl": "https://www.youtube.com/watch?v=UF8uR6Z6KLc&t=338s"
    },
    {
      "startSeconds": 547,
      "endSeconds": 572,
      "startLabel": "9:07",
      "endLabel": "9:32",
      "score": 0.55,
      "heatmapIntensity": 1,
      "commentMentions": 0,
      "reasons": [
        "most replayed (intensity 1.00)"
      ],
      "sources": [
        "heatmap"
      ],
      "transcriptExcerpt": null,
      "commentQuotes": null,
      "watchUrl": "https://www.youtube.com/watch?v=UF8uR6Z6KLc&t=547s"
    },
    {
      "startSeconds": 755,
      "endSeconds": 780,
      "startLabel": "12:35",
      "endLabel": "13:00",
      "score": 0.52,
      "heatmapIntensity": 0.9462,
      "commentMentions": 0,
      "reasons": [
        "most replayed (intensity 0.95)"
      ],
      "sources": [
        "heatmap"
      ],
      "transcriptExcerpt": null,
      "commentQuotes": null,
      "watchUrl": "https://www.youtube.com/watch?v=UF8uR6Z6KLc&t=755s"
    }
  ],
  "nextError": null,
  "scrapedAt": "2026-11-18T05:55:04.286543+00:00",
  "charged": true
}
```

You can view results as a table in the Console, or get them from the API in JSON, CSV, Excel, XML or HTML.

### FAQ

#### Does every video have a Most Replayed heatmap?

No. Shorts, very short videos and some new uploads do not. The Actor still uses the transcript and comment timestamps when those exist.

#### What if there is no transcript?

The video can still be charged if a heatmap or comments were read. Moments will have less context.

#### Are comment timestamps always accurate?

Viewers sometimes joke or post a time that is not a highlight. We cluster repeats and combine them with the heatmap so a single stray "3:21" does not win on its own.

#### Do I need captions enabled?

Auto-captions or manual captions both work when YouTube exposes them via InnerTube. Some videos have none.

#### Can I use it through the API, MCP or integrations?

Yes. Every run is available through the Apify API and the official Python and JavaScript clients, and the Actor can be called by AI agents through the Apify MCP server. Integrations include Make, n8n, Zapier, Google Sheets, Slack and webhooks.

#### Is it legal to scrape this data?

The Actor only collects publicly available data and does not log in or bypass access controls. You are responsible for how you use the results: respect the source site's terms, copyright and privacy laws such as GDPR, and do not collect personal data without a legal basis. If in doubt, ask a lawyer.

#### Something did not work. What should I do?

Open an issue on the **Issues** tab with your run link. We usually answer within a day and fix breakages quickly.

### Other Van Born Labs Actors

| Actor | What it does |
|---|---|
| [YouTube Transcript Scraper — Bulk & Captions](https://apify.com/vanborn_labs/youtube-transcript-scraper-bulk) | Get YouTube transcripts (captions/subtitles) in bulk from videos, Shorts, channels, playlists or search results |
| [YouTube Comments Scraper — Replies, No API Key](https://apify.com/vanborn_labs/youtube-comments-scraper-fast) | YouTube comments scraper for comment text, replies, likes, authors, pinned and creator-hearted flags |
| [Clip Views & Earnings Tracker — TikTok, Shorts](https://apify.com/vanborn_labs/clip-views-earnings-tracker) | Track views, likes, comments and estimated payout for TikTok, YouTube Shorts and Instagram Reels URLs |
| [Content Rewards Scraper — CPM & Budget Left](https://apify.com/vanborn_labs/content-rewards-campaigns-monitor) | Content Rewards scraper for public clipping and UGC campaigns: $ per 1,000 views (CPM), budget left, daily burn, days of runway, platforms and an opportunity score |

More tools: [Van Born Labs on Apify](https://apify.com/vanborn_labs).

# Actor input Schema

## `videos` (type: `array`):

Long YouTube videos or podcasts to analyse. Shorts usually have little or no Most Replayed data.

## `maxVideos` (type: `integer`):

Cap on videos processed (and charged) in this run.

## `maxMoments` (type: `integer`):

Maximum clip timestamps returned per video, ranked by score.

## `clipSeconds` (type: `integer`):

Suggested clip window around each moment, in seconds.

## `maxComments` (type: `integer`):

Used to find timestamps viewers mention (e.g. 3:21).

## `maxConcurrency` (type: `integer`):

How many videos to analyse in parallel (1–6).

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

YouTube often blocks cloud IPs (LOGIN_REQUIRED). Leave the default Apify datacenter proxy on for platform runs. Do not enable residential groups unless a run is still blocked.

## Actor input object example

```json
{
  "videos": [
    "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
  ],
  "maxMoments": 8,
  "clipSeconds": 25,
  "maxComments": 40,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "videos": [
        "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
    ],
    "maxMoments": 8,
    "maxComments": 40,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("vanborn_labs/youtube-viral-moments-finder").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 = {
    "videos": ["https://www.youtube.com/watch?v=UF8uR6Z6KLc"],
    "maxMoments": 8,
    "maxComments": 40,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("vanborn_labs/youtube-viral-moments-finder").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 '{
  "videos": [
    "https://www.youtube.com/watch?v=UF8uR6Z6KLc"
  ],
  "maxMoments": 8,
  "maxComments": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call vanborn_labs/youtube-viral-moments-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vanborn_labs/youtube-viral-moments-finder"
        }
    }
}
```

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/Dr7CyiE81HgOLzewd/builds/FF3DwnZ1qlJfBOtZ4/openapi.json
