# Short Drama Trends — Cross-Platform Rankings & Daily Movers (`signalbench/short-drama-trends`) Actor

Rank the DramaBox and ReelShort short drama catalogs in one leaderboard: views, followers, episodes, genres. Every record carries day-over-day deltas and a new-title flag, so scheduled runs show what moved. Vertical drama and micro drama market data, SSR-JSON based — no browser.

- **URL**: https://apify.com/signalbench/short-drama-trends.md
- **Developed by:** [SignalBench](https://apify.com/signalbench) (community)
- **Categories:** Videos, Other, Automation
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Short Drama Trends — Cross-Platform Rankings & Daily Movers

One leaderboard for the two biggest vertical short-drama apps. This Actor collects the
**DramaBox** and **ReelShort** catalogs, normalizes them into a single schema, ranks them
together, and — from the second run onwards — tells you **what moved**: views gained,
followers gained, episodes added, and which titles are brand new.

It reads each site's server-rendered JSON directly. No browser, no API key, no login.

### What you get

One dataset item per title, identical shape on both platforms:

| Field | Notes |
|---|---|
| `rank`, `platformRank`, `sortedBy` | Position in the combined leaderboard and within its own platform |
| `platform`, `id`, `title`, `url` | `platform` + `id` is the stable join key across runs |
| `views`, `follows`, `episodes` | The three counters. `follows` is DramaBox followers / ReelShort collects |
| `viewsDelta`, `followsDelta`, `episodesDelta` | Change since your previous run — the actual product |
| `isNew`, `comparedTo` | `isNew` flags a title absent from the last run; `comparedTo` timestamps the baseline |
| `genres`, `tags`, `rating` | Each platform's own taxonomy, plus tropes/themes |
| `cover`, `description`, `releaseDate`, `lastUpdatedAt` | |
| `durationSec`, `imdbUrl`, `cast` | ReelShort only — DramaBox no longer publishes cast names |
| `snapshotDate`, `scrapedAt` | Group by `snapshotDate` to build a time series |

A run summary (totals per platform, new titles, top ten movers) is saved to the key-value
store as `SUMMARY`.

### Getting movement data

Deltas need a baseline, so **the first run reports `isNew: true` and null deltas for
everything** — that run is the baseline. Every run afterwards compares against it.

Point an Apify **Schedule** at this Actor (daily is the natural cadence) and each day's
dataset is both a snapshot and a diff. The counters live in a named key-value store
(`short-drama-trends-state` by default); use a different name per ranking if you track
several genres separately, so they don't overwrite each other.

### Input

| Input | Default | What it does |
|---|---|---|
| **Platforms** | Both | Rank DramaBox, ReelShort, or one merged leaderboard |
| **Max titles per platform** | 50 | Collected per platform *before* filtering and ranking |
| **Rank by** | Views | Views, followers, episodes, biggest view gain, or newest release |
| **Genre / theme filter** | — | e.g. `Romance`, `Werewolves`, `Second Chance`, `Time Travel` |
| **Minimum views** | — | Drop titles below a view threshold |
| **Exact view counts & extra details** | On | Visit each title's page (see below) |
| **Track day-over-day changes** | On | Remember counters so the next run can diff |
| **Proxy** | — | Optional; see *Rate limits* |

Filters run **after** collection, so a narrow genre or a high `minViews` can return fewer
titles than `maxItemsPerPlatform`. Raise the cap to widen the net.

#### Exact view counts

With this on (the default), each title's own page is fetched, which is the **only** place
DramaBox publishes a view count. The figure on its listing rows looks like one and isn't:
the same title reads `19.4K` in the listing and **6,041,483 views** on its own page.

- **On** — DramaBox view counts are exact; ReelShort adds runtime, IMDb link, cast and
  release date.
- **Off** — faster and cheaper. ReelShort counts stay exact (its listings publish real
  integers, views and collects alike). DramaBox reports `views: null` rather than a number
  that would understate a hit by three orders of magnitude — the site's own string is kept
  verbatim in `viewsDisplay` — while its **followers and episode counts stay accurate**, so
  rank by followers on these runs.

### Rate limits

Both sites are happy with a normal run and need no proxy. Under sustained hammering
ReelShort starts answering `HTTP 202` with an empty body; the Actor treats that as a block,
backs off exponentially and retries on a fresh session.

If you do enable a proxy, note that **DramaBox rejects Apify's datacenter IPs with a 403**
while serving a direct connection normally. Rather than hand you an empty DramaBox half,
the Actor crawls DramaBox directly whenever the proxy is datacenter-only, and says so in the
log. Pick the **residential** group if DramaBox traffic must go through a proxy. ReelShort
works through either.

### Pricing

Pay per result: **$0.004 per title stored**, and nothing else. A title is only stored when
it carries an identity and at least one real counter, so pages that fail, empty listings and
filtered-out titles are never charged. A search that matches nothing costs **$0.00**.

### Notes & limits

- **Ranking is within what you collected.** Both catalogs run to thousands of titles;
  `maxItemsPerPlatform` decides how deep the sample goes. A catalog run seeds from each
  site's merchandised front page, so a small run is biased toward what the platforms are
  currently pushing — raise the cap for a truer top-N.
- **View counts are platform-reported** and not comparable in an accounting sense across
  the two apps; they are comparable *to themselves over time*, which is what the deltas use.
- **A genre is resolved against each platform's own taxonomy** where one exists — plurals
  are handled, so `Werewolves` finds ReelShort's `Werewolf` tag. Where it can't be resolved
  (a typo, or one of the few ReelShort tags whose page 404s), the Actor falls back to a
  catalog crawl matched against each listing's own themes. That fallback sees only
  listing-level themes, so it returns noticeably fewer titles — the log says when it happens.

# Actor input Schema

## `platforms` (type: `string`):

Which short-drama catalogs to rank. "Both" produces one merged leaderboard across DramaBox and ReelShort.

## `maxItemsPerPlatform` (type: `integer`):

How many titles to collect from each platform before ranking. 50 covers the merchandised front of both catalogs; raise it for deeper coverage (each platform lists a few thousand titles).

## `sortBy` (type: `string`):

How the leaderboard is ordered. "Biggest view gain" ranks by movement since the previous run, so it only means anything on the second run onwards.

## `genre` (type: `string`):

Optional. Restrict the ranking to one genre, theme or trope — e.g. "Romance", "Werewolves", "Time Travel", "Second Chance". Resolved against each platform's own taxonomy where possible; otherwise matched against every title's genres and tags.

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

Optional. Drop titles below this view count — useful for filtering out brand-new releases with no traction yet.

## `fetchDetails` (type: `boolean`):

Visit each title's page for exact DramaBox view counts and ReelShort runtime, IMDb link, cast and release date. Turn it off for a faster, listing-only run — DramaBox view counts then come from the site's rounded display string (e.g. "19.6K").

## `trackChanges` (type: `boolean`):

Remember each title's counters in a named key-value store so the next run can report view/follower/episode deltas and flag new titles. Schedule this Actor daily to build a time series.

## `stateStoreName` (type: `string`):

Named key-value store holding the previous run's counters. Use separate names to track separate rankings (e.g. one per genre) without them overwriting each other.

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

Optional. Both sites serve plain SSR HTML and normally respond fine without a proxy. Note that DramaBox rejects Apify's datacenter IPs with a 403 — if you select a datacenter proxy, DramaBox is crawled directly instead (the log says so); choose the residential group if DramaBox traffic must be proxied. ReelShort works through either.

## Actor input object example

```json
{
  "platforms": "both",
  "maxItemsPerPlatform": 50,
  "sortBy": "views",
  "genre": "Romance",
  "fetchDetails": true,
  "trackChanges": true,
  "stateStoreName": "short-drama-trends-state"
}
```

# Actor output Schema

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

The full ranked leaderboard in JSON.

## `resultsCsv` (type: `string`):

The ranked leaderboard as a CSV export.

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

Totals per platform, new titles, and the ten biggest view gains since the previous run.

## `viewInConsole` (type: `string`):

Open the run and its dataset in the Apify Console.

# 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("signalbench/short-drama-trends").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("signalbench/short-drama-trends").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 signalbench/short-drama-trends --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalbench/short-drama-trends"
        }
    }
}

```

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/NTgzkRiC3TP5kA2jc/builds/gSRynG0IAfFKCWiHA/openapi.json