# ReelShort Book Detail Scraper — Episodes & Cast (`spider_studio/reelshort-book-detail`) Actor

Extract ReelShort title details by book ID, including episodes, cast, covers, synopses, views, paywall position, themes, tags, and related dramas.

- **URL**: https://apify.com/spider\_studio/reelshort-book-detail.md
- **Developed by:** [NewLai](https://apify.com/spider_studio) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 reelshort book details

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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

### What does ReelShort Book Detail Scraper do?

ReelShort Book Detail Scraper is a **ReelShort API alternative** for extracting
complete short-drama details, episode lists, and cast data by book ID. Submit up to
1,000 [ReelShort](https://www.reelshort.com/) titles in one run and receive structured
records covering descriptions, engagement, availability, paywall position,
publication dates, related titles, and recommendations.

Use this Actor to enrich results from ReelShort recommendation or search datasets,
build short-drama catalogs, analyze episode structures, compare content strategies,
or prepare title data for dashboards and research workflows.

### Explore the ReelShort Actor suite

Use these Actors together to move from title discovery to episode-level data and
authorized media downloads.

| Actor | Best for | Key output |
| --- | --- | --- |
| [ReelShort Scraper](https://apify.com/spider_studio/reelshort-landing-page) | Discover trending short dramas from the recommendation feed. | `bookId` and title metadata |
| [ReelShort Search Scraper](https://apify.com/spider_studio/reelshort-search) | Find dramas by title, genre, trope, theme, or phrase. | `bookId` and matching titles |
| [ReelShort Book Detail Scraper](https://apify.com/spider_studio/reelshort-book-detail) | Enrich a title with episodes, cast, recommendations, and availability. | `bookId`, `chapterId`, and title details |
| [ReelShort Episode Scraper](https://apify.com/spider_studio/reelshort-chapter-content) | Inspect chapters and retrieve available decrypted playback links. | Episode metadata and HLS URLs |
| [ReelShort Video Downloader](https://apify.com/spider_studio/reelshort-m3u8-downloader) | Save accessible episodes as best-quality MP4 files. | MP4 files and download metadata |

### Why scrape ReelShort book details, episodes, and cast?

- Turn ReelShort book IDs into complete title records.
- Collect canonical IDs, titles, covers, synopses, languages, themes, and tags.
- Compare episode counts, locked and unlocked chapters, and paywall positions.
- Analyze views, collections, scores, availability, and publication dates.
- Discover cast members with profile images and audience counts.
- Retrieve detailed chapter records, including duration, likes, status, and access.
- Find related titles and ReelShort recommendations.
- Export results to JSON, CSV, Excel, XML, RSS, or JSONL.
- Connect datasets to the Apify API, schedules, webhooks, and integrations.

### What ReelShort book and episode data can this Actor extract?

#### Identity and descriptive metadata

| Field | Description |
| --- | --- |
| `requestedBookId` | Book ID supplied in the input. |
| `bookId` | Canonical ReelShort book ID. |
| `transportBookId` / `sourceBookId` | Additional catalog identifiers when available. |
| `title` / `subtitle` | Series title and subtitle. |
| `description` | Full series synopsis. |
| `coverUrl` | Series cover image URL. |
| `language` | Primary language code. |
| `themes` / `tags` | Normalized themes, genres, and story tropes. |
| `shareText` / `shareUrl` | Sharing text and public title URL. |

#### Popularity, classification, and availability

| Field | Description |
| --- | --- |
| `readCount` | Platform-reported view or read count. |
| `collectCount` | Number of user collections. |
| `score` / `originalScore` | Current and original platform scores. |
| `bookType` / `bookSource` / `bookGenre` | ReelShort classification codes. |
| `status` / `updateStatus` / `preheatStatus` | Current release and availability states. |
| `isPaid` / `isVipOnly` | Payment and VIP access indicators. |
| `hasVideo` / `hasTrailer` | Video and trailer availability. |
| `isDubbed` / `isAiGenerated` / `isEarlyAccess` | Content format indicators. |
| `publishedAt` / `firstPublishedAt` | Publication timestamps. |
| `authorizationEndDate` | Content authorization end date when available. |

#### Episode and paywall details

| Field | Description |
| --- | --- |
| `chapterCount` | Episode count reported for the title. |
| `parsedChapterCount` | Number of chapter records returned. |
| `lockedChapterCount` | Number of locked chapters. |
| `unlockedChapterCount` | Number of unlocked chapters. |
| `firstChapterId` / `landingChapterId` | First and opening chapter IDs. |
| `startPlayEpisode` | Episode selected when playback begins. |
| `paidStartEpisode` | First episode requiring payment. |
| `firstLockedEpisode` | First chapter currently marked as locked. |
| `chapterUpdatedAt` / `chapterPublishedAt` | Chapter update and publication timestamps. |

Each item in `chapters` can include:

- `chapterId`, `chapterName`, and `serialNumber`
- `videoId`, `coverUrl`, and `duration`
- `likeCount`, `publishedAt`, and `aspectRatio`
- `screenMode` and `videoType`
- `isLocked`, `vipFree`, `adVipLocked`, and `isWatched`
- `status` and any additional source fields in `raw`

#### Cast and discovery fields

The `cast` array can include `actorId`, `name`, `photoUrl`, `gender`,
`followerCount`, and `titleCount`. The output can also contain normalized
`recommendations`, `relatedBooks`, series-collection metadata, subtitle languages,
editorial labels, and the complete supplementary data object in `raw`.

### How to scrape ReelShort book details and episodes

1. Collect valid ReelShort `bookId` values from a recommendation or search dataset.
2. Open this Actor's **Input** tab.
3. Paste one or more IDs into **ReelShort book IDs**.
4. Click **Start** and wait for the run to finish.
5. Open the **Output** or **Dataset** tab to inspect, filter, and download the data.

No code is required. Developers can also start runs and retrieve results through the
Apify API, SDKs, CLI, webhooks, or MCP integrations.

### How much does it cost to scrape ReelShort details?

This Actor uses pay-per-result pricing:

| Apify plan | Price per result | Price per 1,000 results |
| --- | ---: | ---: |
| Free plan | $0.003 | $3.00 |
| Paid plans | $0.002 | $2.00 |

Only successfully parsed ReelShort book-detail results are billed. Invalid IDs,
failed requests, and empty details do not create charged Dataset rows. Check each
run's **Usage** tab for the exact charge.

### Input

The Actor accepts one required field:

| Field | Type | Limit | Description |
| --- | --- | ---: | --- |
| `bookIds` | array of strings | 1,000 | ReelShort book IDs to retrieve. |

Whitespace is removed and duplicate IDs are ignored while preserving their original
order.

Example input:

```json
{
  "bookIds": [
    "6a90e563e9df3108b20a4617",
    "6a850fc824d230ed1b0b190d"
  ]
}
```

### Output

You can download the Dataset in formats such as JSON, CSV, Excel, HTML, XML, RSS, or
JSONL. Each requested title produces one top-level record.

```json
{
  "requestedBookId": "69c0a298c87f09a7e10d8ffe",
  "bookId": "69c0a298c87f09a7e10d8ffe",
  "transportBookId": "200000000000002373",
  "success": true,
  "language": "en",
  "title": "Married The Mafioso I Saved",
  "coverUrl": "https://cdn.example.com/cover.jpg",
  "chapterCount": 54,
  "parsedChapterCount": 55,
  "lockedChapterCount": 43,
  "unlockedChapterCount": 12,
  "paidStartEpisode": 12,
  "firstLockedEpisode": 12,
  "readCount": 241874546,
  "collectCount": 3736630,
  "isPaid": true,
  "hasTrailer": true,
  "themes": ["Mafia"],
  "tags": ["Mafia"],
  "cast": [
    {
      "actorId": "actor-1",
      "name": "Example Actor",
      "photoUrl": "https://cdn.example.com/actor.jpg"
    }
  ],
  "chapters": [
    {
      "chapterId": "chapter-1",
      "chapterName": "Episode 1",
      "serialNumber": 1,
      "duration": 177,
      "likeCount": 15394,
      "isLocked": false
    }
  ],
  "recommendations": [],
  "relatedBooks": [],
  "error": null
}
```

### Tips for better ReelShort detail data

- Use `bookId` values returned by a current ReelShort search or recommendation run.
- Keep `requestedBookId` when joining output back to the source dataset.
- Compare `chapterCount` with `parsedChapterCount`; some titles include an Episode 0.
- Use `paidStartEpisode` and `firstLockedEpisode` when analyzing monetization patterns.
- Schedule recurring runs to monitor engagement, availability, and chapter updates.

### FAQ, disclaimer, and support

#### Why did a title return no details?

The ID may be an example, expired, mistyped, or from another catalog. Use a current
`bookId` from a ReelShort recommendation or search result.

#### Does this Actor download episodes?

No. It collects title and chapter metadata. It does not download or store video
files.

#### Why can `chapterCount` differ from `parsedChapterCount`?

Some titles include a separately numbered Episode 0. The reported title count and
the number of returned chapter records can therefore differ by one.

#### Can I process multiple titles at once?

Yes. A single run accepts up to 1,000 unique ReelShort book IDs.

> This Actor collects content made available by the target service. Results may still
> contain personal or protected data. Use the Actor only for legitimate purposes,
> follow ReelShort's terms, and consult legal counsel when your collection or use may
> be regulated.

Use the Actor's **Issues** tab for reproducible bug reports and its **API** tab for
programmatic access.

# Actor input Schema

## `bookIds` (type: `array`):

Book IDs returned by the landing page or search Actor. Duplicate IDs are ignored.

## Actor input object example

```json
{
  "bookIds": [
    "6a90e563e9df3108b20a4617"
  ]
}
```

# Actor output Schema

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

One detailed ReelShort title record with episodes, cast, metadata, and paywall information.

# 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 = {
    "bookIds": [
        "6a90e563e9df3108b20a4617"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/reelshort-book-detail").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 = { "bookIds": ["6a90e563e9df3108b20a4617"] }

# Run the Actor and wait for it to finish
run = client.actor("spider_studio/reelshort-book-detail").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 '{
  "bookIds": [
    "6a90e563e9df3108b20a4617"
  ]
}' |
apify call spider_studio/reelshort-book-detail --silent --output-dataset

```

## MCP server setup

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

```

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/sdn0Z6zrrUQ6eJNij/builds/qOYpCb8xMHhmvnxlo/openapi.json