# 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:** 4 total users, 0 monthly users, 82.4% 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DramaBox Scraper — Catalog, Episodes, Cast & View Counts",
        "description": "Scrape the DramaBox short-drama catalog: series metadata, genres, tags, episode lists, cast, view & follow counts. SSR-JSON based (no browser) — fast and cheap.",
        "version": "1.0",
        "x-build-id": "egXcqfeIJcJx7w6HD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/signalbench~dramabox-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-signalbench-dramabox-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/signalbench~dramabox-scraper/runs": {
            "post": {
                "operationId": "runs-sync-signalbench-dramabox-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/signalbench~dramabox-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-signalbench-dramabox-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "catalog",
                            "genre",
                            "urls"
                        ],
                        "type": "string",
                        "description": "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.",
                        "default": "catalog"
                    },
                    "genre": {
                        "title": "Genre (for \"By genre\" mode)",
                        "enum": [
                            "Romance",
                            "Urban",
                            "Fantasy",
                            "Family",
                            "Suspense",
                            "Paranormal",
                            "Comedy",
                            "Humor",
                            "Time Travel",
                            "Alternative History",
                            "Super Power",
                            "Rebirth",
                            "Werewolves",
                            "Werewolf",
                            "Revenge",
                            "Avenge",
                            "Counterattack",
                            "Comeback",
                            "Underdog Rise",
                            "CEO",
                            "Billionaire",
                            "Divine Tycoon",
                            "Son-in-Law",
                            "Strong Female Lead",
                            "Badboy",
                            "Mafia",
                            "Influencer",
                            "Small Potato",
                            "Trending",
                            "Secret Identity",
                            "Concealed Identity",
                            "Love Triangle",
                            "Second-chance Love",
                            "Marriage",
                            "Contract Marriage",
                            "Marriage Before Love",
                            "Contract Lover",
                            "Soulmate",
                            "Destiny",
                            "True Love",
                            "Sweet Love",
                            "Bitter Love",
                            "Toxic Love",
                            "Toxic Relationship",
                            "Turbulent Love",
                            "Forbidden Love",
                            "Enemies to Lovers",
                            "Betrayal",
                            "Misunderstanding",
                            "Twisted"
                        ],
                        "type": "string",
                        "description": "Which genre to scrape. Uses DramaBox's official genre browse pages, so results are exactly the titles DramaBox files under that genre.",
                        "default": "Romance"
                    },
                    "dramaUrls": {
                        "title": "Drama URLs (for \"Specific drama URLs\" mode)",
                        "type": "array",
                        "description": "DramaBox series URLs, e.g. https://www.dramabox.com/drama/42000010883/think-again-im-the-hidden-boss-mom",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of series to store. This caps your cost — 1 stored series = 1 charge.",
                        "default": 50
                    },
                    "includeChapters": {
                        "title": "Include episode list",
                        "type": "boolean",
                        "description": "Include the full per-episode list (episode number, title, duration, unlock status). Turn off for smaller records.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "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.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```