# ReelShort Scraper — Catalog, Themes, Cast, IMDb & View Counts (`signalbench/reelshort-scraper`) Actor

Scrape the ReelShort short-drama catalog: titles, themes & tags, episode counts, cast, IMDb links, view & collect counts. SSR-JSON based (no browser) — fast and cheap.

- **URL**: https://apify.com/signalbench/reelshort-scraper.md
- **Developed by:** [SignalBench](https://apify.com/signalbench) (community)
- **Categories:** Videos, Other
- **Features:** Limited permissions
- **Stats:** 73 total users, 11 monthly users, 97.1% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.40 / 1,000 title scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## ReelShort Scraper — Catalog, Themes, Cast, IMDb & View Counts

Scrape the **ReelShort** vertical short-drama catalog without the app: **title
metadata, theme & trope tags, episode counts, cast with IMDb links, view counts
and collect 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 **ReelShort API / ReelShort 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
> titles** ($0.002 each), billed only per title actually stored. Invalid or
> failed pages are never charged.

### What it scrapes

| Field | Description |
|---|---|
| **bookId / title** | Title ID (and transport ID) and name |
| **synopsis** | Full description |
| **themes / tags** | Card theme tropes plus the full tag list (Sweet Romance, Hidden Identity, Feel-Good, …) |
| **readCount / collectCount / score** | Platform-reported views, collects, and popularity score |
| **chapterCount** | Number of episodes |
| **cast\[] + imdbId / imdbUrl** | Cast with photos and IMDb actor links, plus the title's IMDb id — a cast index that exists nowhere else publicly |
| **durationSec** | First-episode duration (detail mode) |
| **releaseDate** | Release date |
| **cover / url** | Cover image and canonical title URL |

### Modes

- **Full catalog (crawl)** — seeds from the ReelShort homepage and expands
  through every featured category. Set **Max results** to cap size and cost.
- **By category** — scrapes one category's full list. Two kinds of category are
  supported, resolved live against the site: **featured homepage shelves**
  (e.g. `Hidden Identity`, `Tear-jerkers`, `Young Love` — one request each) and
  **genre/identity/trope tags** from ReelShort's Genre browse (e.g. `Crime Lord`,
  `Single Dad`, `Comedy`, `Revenge` — paginated, often hundreds of titles). The dropdown
  lists every shelf plus all identity, trope, genre, theme and mood tags; via JSON/API
  input you can also pass an actor's name to scrape their filmography, resolved live.
- **Specific title URLs** — scrape exactly the ReelShort episode URLs you provide.

Turn **Include cast, IMDb & full tags** off for a faster, cheaper run that uses
only the listing data (title, themes, episode count, view & collect counts).

### Input example

```json
{
    "mode": "category",
    "category": "Hidden Identity",
    "maxItems": 200,
    "includeDetails": true
}
```

### Output example

```json
{
    "source": "reelshort",
    "bookId": "68955a832bc50c718b009d8d",
    "title": "Daisy Tucker and Mr. NYC",
    "url": "https://www.reelshort.com/episodes/episode-1-daisy-tucker-and-mr-nyc-68955a832bc50c718b009d8d-fxcfjh1dzy",
    "themes": ["Sweet Romance"],
    "tags": ["Feel-Good", "Reunited Lovers", "Sweet Romance"],
    "chapterCount": 77,
    "readCount": 52286934,
    "collectCount": 256270,
    "score": 9183,
    "durationSec": 168,
    "imdbId": "tt37855561",
    "imdbUrl": "https://www.imdb.com/title/tt37855561/",
    "cast": [{ "actorName": "Richard Sharrah", "imdbUrl": "https://www.imdb.com/name/nm5340956/" }],
    "releaseDate": "2025-08-11T07:00:00.000Z",
    "scrapedAt": "2026-06-14T03:25:00.000Z"
}
```

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 which themes, 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 with IMDb links is a
  performer index for verticals that no public database covers.
- **Market & trend analysts** — engagement signals (views, collects, score) per
  title, theme, and release date.

### How it works

ReelShort is a Next.js site that ships full structured data in the page's
`__NEXT_DATA__` payload (homepage feed, category lists, and per-title detail).
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. It scrapes only **public catalog 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 title 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 ReelShort API?** Not a public one. This Actor is the practical,
available-today way to get structured ReelShort data.

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

**Are the view/collect counts exact?** They're the platform's own reported
numbers. Treat them as platform-reported figures.

**Why do view count and score appear in detail mode too?** The detail page omits
them, so the Actor merges them in from the listing — you get cast/IMDb/tags *and*
engagement counts in one record.

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

### Feedback and reviews

Missing a field, hit a bug, or need another input option? Open an issue on the
[Issues tab](https://apify.com/signalbench/reelshort-scraper/issues). Requests there shape what gets built next.

If this Actor saved you time, please leave a [quick review](https://apify.com/signalbench/reelshort-scraper/reviews). Reviews are
how other users find it on the Apify Store, and they keep it maintained.

# Actor input Schema

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

What to scrape. **Full catalog** crawls the homepage and every featured category. **By category** scrapes one category's full list (server-side, one page). **Specific title URLs** scrapes only the ReelShort episode URLs you provide.

## `category` (type: `string`):

Which category to scrape, resolved live against ReelShort. The list covers every featured homepage shelf plus ReelShort's Genre-browse tags — character identities, story tropes, genres, themes and moods. **Advanced (JSON/API input):** you can also pass an actor's name to scrape their filmography; the run resolves any value live and fails with a pointer to the full tag list if it doesn't exist.

## `titleUrls` (type: `array`):

ReelShort episode URLs, e.g. https://www.reelshort.com/episodes/episode-1-daisy-tucker-and-mr-nyc-68955a832bc50c718b009d8d-fxcfjh1dzy

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

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

## `includeDetails` (type: `boolean`):

Fetch each title's detail page to add cast, IMDb links and the full tag list. Turn off for a faster, cheaper run that uses only the listing data (title, themes, episode count, view & collect counts).

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

Apify Proxy. **Residential is required** — ReelShort'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",
  "category": "Hidden Identity",
  "titleUrls": [],
  "maxItems": 50,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped titles in JSON.

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

All scraped titles 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 = {
    "titleUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("signalbench/reelshort-scraper").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 '{
  "titleUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call signalbench/reelshort-scraper --silent --output-dataset

```

## MCP server setup

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

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/xHxGYQrNEeDLcWaKw/builds/Z1nSezZCnzzO5adaQ/openapi.json