# DramaBox Scraper — Catalog, Episodes, Cast & View Counts (`signalbench/dramabox-scraper`) Actor

Scrape the DramaBox short-drama catalog: series metadata, genres, tags, episode lists, cast, view & follow counts. SSR-JSON based (no browser) — fast and cheap.

- **URL**: https://apify.com/signalbench/dramabox-scraper.md
- **Developed by:** [SignalBench](https://apify.com/signalbench) (community)
- **Categories:** Videos, Other
- **Stats:** 33 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/platform/actors/running/actors-in-store#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

## DramaBox Scraper — Short-Drama Catalog, Episodes, Cast & View Counts

Scrape the **DramaBox** vertical short-drama catalog without the app: **series
metadata, genres & trope tags, full episode lists, cast, view counts and follow
counts** — structured, ready for analysis. API-first (reads the site's own SSR
JSON, **no browser**), so runs are fast, cheap, and reliable. Export as **JSON,
CSV, Excel, or XML**, or pull straight through the Apify API into your app,
agent, notebook, or spreadsheet.

This is the missing **DramaBox API / DramaBox data** source: the $11.3B
short-drama category has had essentially zero structured-data coverage. If you're
a studio, licensor, casting researcher, or analyst asking *"what's charting and
what should we greenlight next?"* — this is your dataset.

> **No per-datapoint games, never charged for failures.** Flat **$2 per 1,000
> series** ($0.002 each), billed only per series actually stored. Invalid or
> failed pages are never charged.

### What it scrapes

| Field | Description |
|---|---|
| **bookId / bookName** | Series ID and title (plus English/slug form) |
| **introduction** | Full synopsis |
| **genres / tags / labels** | Genre IDs + names and trope tags (Revenge, CEO, Billionaire, Werewolf, …) |
| **viewCount / followCount** | Platform-reported engagement (approximate display values, parsed to integers) |
| **chapterCount + chapters\[]** | Episode count and the full episode list — number, title, duration, free/locked |
| **cast\[]** | Performer list (id, name, avatar, # of titles) — a cast index that exists nowhere else publicly |
| **releaseDate / lastUpdateTime** | First-live date and latest shelf update |
| **cover / url** | Cover image and canonical series URL |

### Modes

- **Full catalog (crawl)** — seeds from the DramaBox homepage and expands through
  each series' related-titles graph. Set **Max results** to cap size and cost.
- **By genre** — the same crawl, filtered to a genre or trope tag (e.g.
  `Billionaire`, `Revenge`, `Werewolf`). Case-insensitive.
- **Specific drama URLs** — scrape exactly the series URLs you provide.

### Input example

```json
{
    "mode": "genre",
    "genre": "Billionaire",
    "maxItems": 200,
    "includeChapters": true
}
```

### Output example

```json
{
    "source": "dramabox",
    "bookId": "42000004343",
    "bookName": "If I Never Loved You",
    "url": "https://www.dramabox.com/drama/42000004343/If-I-Never-Loved-You",
    "language": "ENGLISH",
    "genres": [{ "id": 161, "name": "Romance" }],
    "tags": ["Second Chance", "Billionaire"],
    "viewCount": 57338269,
    "followCount": 2295193,
    "chapterCount": 50,
    "releaseDate": "2026-01-20 16:00:00",
    "cast": [{ "performerId": "12070", "performerName": "Dorothy Mannine", "videoCount": 3 }],
    "chapters": [{ "id": "700278553", "episode": 1, "name": "第一集", "durationMs": 179954, "unlocked": true }],
    "scrapedAt": "2026-06-12T20:02:17.911Z"
}
```

Export the dataset as **CSV, Excel, JSON, or XML** from the Apify Console, or
fetch it via the Apify API / SDK.

### Who uses this

- **Vertical-drama studios & producers** — track what genres, tropes, and titles
  are charting to inform what to greenlight.
- **Licensors & distributors** — catalog intelligence across the fast-growing
  short-drama market.
- **Casting & talent researchers** — the `cast` list is a performer index for
  verticals that no public database covers.
- **Market & trend analysts** — engagement signals (views, follows) per series,
  genre, and release date.

### How it works

DramaBox is a Next.js site that ships full structured data in the page's
`__NEXT_DATA__` payload. The Actor reads that JSON directly with a browser-grade
HTTP fingerprint (via Crawlee) — no headless browser to render or break, which is
why runs are fast and cheap. The crawler respects `robots.txt` (it does **not**
touch disallowed paths such as search) and scrapes only **public series
metadata** — no video assets, no user data.

### Use it from n8n, Zapier, Make, MCP, and LangChain

Every Apify Actor is exposed via API and through Apify's integrations:

- **n8n / Zapier / Make** — run on a schedule and pipe series data into sheets,
  dashboards, or alerts.
- **MCP / LangChain** — give an AI agent live short-drama catalog data as a tool.
- **Apify API & SDK** — call it from your backend, then export CSV/JSON.

### FAQ

**Is there a DramaBox API?** Not a public one. This Actor is the practical,
available-today way to get structured DramaBox data.

**How much does it cost?** $0.002 per stored series — **$2 per 1,000**. You're
never charged for failed or invalid pages. The free Apify plan's $5 monthly
credit covers ~2,500 series.

**Are the view/follow counts exact?** They're the platform's own reported numbers
(originally display values like "57.3M"), parsed to integers. Treat them as
approximate, platform-reported figures.

**Is scraping this legal?** The Actor extracts publicly available catalog
metadata and respects `robots.txt`. As always, consult your own counsel for your
specific use case.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. **Full catalog** crawls the homepage and expands via each series' related-titles graph. **By genre** pulls a genre's official browse page (server-side filtered, paginated) — exact and efficient. **Specific drama URLs** scrapes only the URLs you provide.

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

Which genre to scrape. Uses DramaBox's official genre browse pages, so results are exactly the titles DramaBox files under that genre.

## `dramaUrls` (type: `array`):

DramaBox series URLs, e.g. https://www.dramabox.com/drama/42000010883/think-again-im-the-hidden-boss-mom

## `maxItems` (type: `integer`):

Maximum number of series to store. This caps your cost — 1 stored series = 1 charge.

## `includeChapters` (type: `boolean`):

Include the full per-episode list (episode number, title, duration, unlock status). Turn off for smaller records.

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

Apify Proxy. **Residential is required** — DramaBox's CDN returns 403 to datacenter IPs. The site has no header/TLS anti-bot, so residential IPs alone are enough.

## Actor input object example

```json
{
  "mode": "catalog",
  "genre": "Romance",
  "dramaUrls": [],
  "maxItems": 50,
  "includeChapters": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped series in JSON.

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

All scraped series as a CSV export.

## `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 = {
    "dramaUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalbench/dramabox-scraper").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 = {
    "dramaUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("signalbench/dramabox-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "dramaUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call signalbench/dramabox-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=signalbench/dramabox-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/zuNvVTib1vYmVNDkP/builds/egXcqfeIJcJx7w6HD/openapi.json