# ReelShort Episode Scraper — Chapters & Video URLs (`spider_studio/reelshort-chapter-content`) Actor

Scrape ReelShort episode details by book and chapter ID, including metadata, subtitles, video qualities, and decrypted URLs ready for direct playback.

- **URL**: https://apify.com/spider\_studio/reelshort-chapter-content.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 episode results

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 Episode Scraper do?

**ReelShort Episode Scraper** extracts structured chapter data and available video
links from [ReelShort](https://www.reelshort.com/) using book and chapter IDs. Available
links are returned already decrypted and ready for direct playback. Use the Actor as an
unofficial ReelShort data API for episode catalogs, content operations, research, and
automated media workflows.

Submit one chapter or a batch of up to 1,000 chapters. Each Dataset row contains the
requested identifiers, episode metadata, availability details, and video options when
they are available. Results remain in input order, making them easy to join with an
existing title catalog.

### 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 use ReelShort Episode Scraper?

- Extract episode titles, positions, duration, thumbnails, and video identifiers.
- Check chapter availability, preview duration, and unlock cost.
- Get decrypted, ready-to-play video links with available resolutions, bandwidths,
  and subtitle languages.
- Process up to 1,000 unique book and chapter ID pairs in one run.
- Store one structured Dataset row for every successfully retrieved chapter.
- Export results as JSON, CSV, Excel, XML, or HTML.
- Schedule recurring runs or connect results to workflows through the Apify API,
  webhooks, and integrations.

### ReelShort episode data use cases

- **Catalog enrichment:** add episode-level metadata to an existing short-drama index.
- **Content operations:** verify episode order, duration, thumbnails, and availability.
- **Media workflows:** pass available video links and quality options to authorized
  downstream systems.
- **Quality assurance:** identify missing, locked, or unavailable chapters in bulk.
- **Research and analytics:** compare episode structure and content availability across
  ReelShort titles.

### What ReelShort chapter data can I extract?

| Field | Type | Description |
| --- | --- | --- |
| `bookId` | string | ReelShort series identifier. |
| `chapterId` | string | ReelShort chapter or episode identifier. |
| `chapterName` | string or null | Chapter or episode title. |
| `serialNumber` | integer or null | Episode position within the series. |
| `videoId` | string or null | ReelShort video identifier. |
| `duration` | integer or null | Episode duration reported by ReelShort. |
| `isLocked` | boolean or null | Whether the episode is currently locked. |
| `trialSeconds` | integer or null | Available preview duration. |
| `playbackUrl` | string or null | Best available decrypted URL, ready for direct playback. |
| `playbackVariants` | array | Decrypted playback options and associated metadata. |
| `qualities` | array | Available resolutions, bandwidths, and video URLs. |
| `subtitleLanguages` | array | Available subtitle language codes. |
| `unlockCost` | integer or null | Reported unlock cost for the episode. |
| `recommendations` | array | Related ReelShort title recommendations. |
| `success` | boolean | Whether the stored chapter result succeeded. |
| `error` | string or null | Reserved field; normally null for stored results. |

### How to scrape ReelShort episodes

1. Get valid `bookId` and `chapterId` values from a ReelShort title or the ReelShort
   Book Detail Scraper.
2. Open this Actor's **Input** tab.
3. Add one or more ID pairs to the `chapters` array.
4. Click **Save & Start**.
5. Open the **Output** tab to review or download the Dataset.

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

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 episode results stored in the default Dataset are
billed. Failed requests do not create charged Dataset rows. Check each run's **Usage**
tab for the exact charge.

### Input

See the Input tab for full configuration options. `chapters` is a JSON array containing
`bookId` and `chapterId` strings. Duplicate pairs are ignored while the original order
is preserved.

```json
{
  "chapters": [
    {
      "bookId": "6a90e563e9df3108b20a4617",
      "chapterId": "6tybvk6hrr"
    }
  ]
}
```

### Output

Results are stored in an Apify Dataset. You can download the Dataset in JSON, HTML,
CSV, Excel, or XML, or access it programmatically through the Apify API.

```json
{
  "bookId": "6a90e563e9df3108b20a4617",
  "chapterId": "6tybvk6hrr",
  "success": true,
  "chapterName": "Episode 1",
  "serialNumber": 1,
  "duration": 103,
  "isLocked": false,
  "subtitleLanguages": ["en"],
  "playbackUrl": "https://cdn.example/video/1080p.m3u8",
  "playbackVariants": [
    {"dpi": 720, "url": "https://cdn.example/video/720p.m3u8"}
  ],
  "qualities": [
    {"width": 1080, "height": 1920, "bandwidth": 4200000}
  ],
  "error": null
}
```

### Tips for reliable ReelShort episode results

- Use IDs from the same ReelShort title; a chapter ID must belong to its book ID.
- Start with the prefilled example to confirm the expected output structure.
- Split very large workflows into repeatable batches for easier monitoring.
- Process playback links promptly because availability can change over time.
- A successful row may contain no video URL when the episode is locked or unavailable.

### FAQ, responsible use, and support

#### Can this Actor unlock paid ReelShort episodes?

No. The Actor reports the content currently available and does not bypass access or
payment restrictions.

#### Does it download ReelShort video files?

No. The Actor returns episode metadata and available playback links. It does not
download or redistribute video files.

#### Are the returned ReelShort video links ready to play?

Yes. Available playback links are returned already decrypted and can be used directly
by compatible video players. Access restrictions still apply, and links may expire or
become unavailable after the run.

#### Can I scrape multiple episodes in one run?

Yes. Add up to 1,000 unique book and chapter ID pairs to the `chapters` input.

#### Why is `playbackUrl` empty?

The episode may be locked, unavailable, restricted, or missing a current playback
option. Check `isLocked` and `status` for more context.

Use this Actor only for legitimate purposes. Follow ReelShort's terms, respect
copyright and applicable law, and make sure your use of the resulting data and links
is authorized. Use the Issues tab for support and the API tab for programmatic access.

# Actor input Schema

## `chapters` (type: `array`):

Book and chapter ID pairs returned by the book detail Actor. Duplicate pairs are ignored.

## Actor input object example

```json
{
  "chapters": [
    {
      "bookId": "6a90e563e9df3108b20a4617",
      "chapterId": "6tybvk6hrr"
    }
  ]
}
```

# Actor output Schema

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

One Dataset row per requested chapter with top-level playback fields.

# 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 = {
    "chapters": [
        {
            "bookId": "6a90e563e9df3108b20a4617",
            "chapterId": "6tybvk6hrr"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/reelshort-chapter-content").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 = { "chapters": [{
            "bookId": "6a90e563e9df3108b20a4617",
            "chapterId": "6tybvk6hrr",
        }] }

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

```

## MCP server setup

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

```

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/lpSRwzfJROcxTA2QK/builds/x7L8o1BbOnobqMxZE/openapi.json