# YouTube Viral & Trend Radar — Shorts & Videos ✅ (`nexascout/youtube-viral-radar`) Actor

Discover YouTube Shorts and videos by topic or channel. Track view growth between runs, compare videos with channel baselines and export ranked research data. No YouTube API key required.

- **URL**: https://apify.com/nexascout/youtube-viral-radar.md
- **Developed by:** [NexaScout](https://apify.com/nexascout) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 video research results

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 & Trend Radar

Find YouTube Shorts and long-form videos by topic or channel, compare their public performance, and measure view growth across repeated runs. Export your research as CSV, Excel or JSON, or connect it to your own workflow. No YouTube API key or sign-in is required.

### What you can research

- Content ideas and video performance in a specific niche.
- Shorts and long-form uploads from channels you follow.
- Changes in exact public view counters between observations.
- Views relative to a channel's available subscriber count.
- A video's lifetime average view rate relative to the median of its tracked channel videos.

Each run returns a bounded sample. Viral scores, content categories, detected language and title-hook signals are heuristics for research.

### Start with a topic

```json
{
  "discoveryModes": ["search"],
  "searchQueries": ["skincare routine", "makeup tutorial"],
  "formats": "short",
  "maxResults": 25,
  "maxAgeHours": 168,
  "saveHistory": true,
  "historyProfile": "beauty-research"
}
```

Use `short`, `long` or `any` for `formats`. To monitor channels, select `["channel"]` and supply public `channelUrls` or @handles. The Channel Video Growth Monitor example starts with NASA; replace it with your channels.

### Measure growth over time

The first observation establishes a baseline. Repeat the same history profile, sources, country and format at least `minIntervalMinutes` later (60 minutes by default). Two sufficiently spaced observations can measure view growth. Three can support acceleration or decline comparisons when the data meets the thresholds.

- `viewsDelta`: change in the exact public view counter.
- `measuredViewsPerHour`: that change divided by elapsed observation time.
- `averageViewsPerHourSincePublished`: lifetime average, separate from measured growth.
- `reachMultiple`: views divided by available subscriber count; rounded subscribers are flagged.
- `velocityVsBaseline`: lifetime average view rate divided by the channel median for its tracked sample.
- `creatorBaselineVideos`: total unique videos tracked for that channel; `baselineWindow` limits the newest observations used for the median.

States include BASELINE, NEW, INSUFFICIENT_INTERVAL, RISING, STABLE, ACCELERATING, DECLINING, STALE_BASELINE and COUNTER_CORRECTION. Acceleration and decline are conditional signals. DECLINING can mean slower growth while total views still increase.

### Output and exports

The dataset includes available titles, channel links, video URLs, format, public counters, publication dates and precision, ranking signals, observations and metric warnings. Missing values remain empty. The overview displays date precision and whether subscribers are rounded.

The run also provides a summary and an HTML research dashboard. Hook signals analyze the title text; the Actor does not watch the video, transcribe speech or analyze its visual opening.

### Pricing

**$0.02 per run start + $0.005 per video returned.** A run returning 25 videos costs $0.145 at the default 1 GB memory setting, before any applicable taxes. The start event is charged per GB of allocated memory, with a minimum of one event; allocating more memory increases the start charge. Each returned video is billed again when returned on a later monitoring run.

The start charge applies even when no matches are returned. Apify platform usage during the run is included in this event-based pricing. Optional paid proxies can add cost. Use output and charge limits to control spending. Actual results can be lower than the requested maximum because of filters, available candidates or collection limits.

### Data limits

- Publication dates can be date-only. For these rows, hourly recency filters allow up to 24 additional hours of uncertainty. Check `publishedAtPrecision`; a proxy does not guarantee exact timestamps.
- Search localization is not creator or audience geography.
- Language and category filters use text heuristics and can misclassify content. Unknown language is kept.
- Channel baselines use videos observed by this history profile, not every upload on the channel.
- Regional Trending is best-effort and can be empty for anonymous sessions. Use niche searches or channel monitoring as the main discovery methods.
- Exact counters and metadata can be unavailable or change. Rounded estimates are flagged separately; missing comment counts or durations are not invented.
- Ranking describes observed public signals, not a prediction of future views, a probability of virality, or a guarantee of commercial performance.

The Actor requests public YouTube pages directly. It does not call another Actor, download media or sign in.

# Changelog

This Actor's version history is a separate document: https://apify.com/nexascout/youtube-viral-radar/changelog.md

# Actor input Schema

## `discoveryModes` (type: `array`):

Search topics or monitor channel tabs. Regional Trending is best-effort and may return no videos for anonymous sessions.

## `searchQueries` (type: `array`):

Up to 10 topic phrases for search discovery. Enter a specific niche; this is a sample of matching videos.

## `channelUrls` (type: `array`):

Public YouTube channel URLs or @handles, used when 'channel' is in discoveryModes.

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

Two-letter country code. Localizes trending/search results; it does NOT identify audience or creator country.

## `formats` (type: `string`):

Which video formats to include: Shorts only, long-form only, or any.

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

Filter by detected content language (heuristic from title/description). 'any' = no filter. Examples: en, pt, es, de, fr. A known mismatch is excluded; unknown language is kept.

## `categories` (type: `array`):

Narrow output to auto-tagged categories. Empty = keep all categories.

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

Minimum exact public view counter. Filtered observations can still be saved to history.

## `maxAgeHours` (type: `integer`):

0 disables. Exact timestamps use the requested window. Date-only data allows up to 24 extra hours of uncertainty; inspect publishedAtPrecision in the output.

## `minReachMultiple` (type: `number`):

Minimum views/subscribers ratio when subscriber data is available. 0 disables. Rounded subscriber counts produce approximate ratios; missing ratios are kept.

## `baselineWindow` (type: `integer`):

Use the newest observations of up to this many unique tracked videos from each channel to calculate its median lifetime view rate. This is a sample of observed videos.

## `maxResults` (type: `integer`):

Maximum paid dataset rows. Collection stops once this limit is reached.

## `maxCandidatesPerSource` (type: `integer`):

Maximum videos discovered per trending feed, query or channel. Does not promise full coverage.

## `maxPagesPerSource` (type: `integer`):

Bounded pagination. Continuations depend on YouTube availability.

## `maxDetailRequests` (type: `integer`):

Hard cap on physical detail requests, including comment enrichment, retries, failed requests and filtered videos.

## `maxRunSeconds` (type: `integer`):

Stops collection early enough to write output and history.

## `minIntervalMinutes` (type: `integer`):

Do not compute view velocity from observations closer than this interval.

## `maxComparisonHours` (type: `integer`):

Older baselines are marked stale. Keep this greater than the minimum interval.

## `risingViewsPerHour` (type: `integer`):

Measured velocity threshold for RISING. Configurable, not a universal viral threshold.

## `accelerationFactor` (type: `number`):

ACCELERATING requires at least this ratio of successive measured velocities and a current velocity above the rising threshold.

## `saveHistory` (type: `boolean`):

Save only verified observations. Reuse the profile and sources for comparisons.

## `historyProfile` (type: `string`):

Separate experiments with separate names. Sources and country also form part of the history identity.

## `includeComments` (type: `boolean`):

Fetch one public comments continuation when the page does not expose an exact count.

## `maxRequestRetries` (type: `integer`):

Retry temporary network errors and HTTP 403/429/5xx responses within existing time and request caps.

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

Direct requests by default. A proxy may improve access to YouTube metadata but adds cost and does not guarantee exact timestamps or access to personalized feeds.

## Actor input object example

```json
{
  "discoveryModes": [
    "search"
  ],
  "searchQueries": [
    "skincare routine"
  ],
  "channelUrls": [],
  "country": "US",
  "formats": "any",
  "language": "any",
  "categories": [],
  "minViews": 0,
  "maxAgeHours": 0,
  "minReachMultiple": 0,
  "baselineWindow": 20,
  "maxResults": 25,
  "maxCandidatesPerSource": 30,
  "maxPagesPerSource": 2,
  "maxDetailRequests": 80,
  "maxRunSeconds": 180,
  "minIntervalMinutes": 60,
  "maxComparisonHours": 72,
  "risingViewsPerHour": 100,
  "accelerationFactor": 1.5,
  "saveHistory": true,
  "historyProfile": "default",
  "includeComments": true,
  "maxRequestRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `dashboard` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexascout/youtube-viral-radar").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexascout/youtube-viral-radar").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 '{}' |
apify call nexascout/youtube-viral-radar --silent --output-dataset

```

## MCP server setup

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

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/Le1pFPmnbbO3ZSDPM/builds/dBMUawpCEephEUGPP/openapi.json