# ReelShort Scraper — Trending Short Drama Recommendations (`spider_studio/reelshort-landing-page`) Actor

Scrape ReelShort's live For You feed for trending short dramas, titles, book IDs, covers, synopses, episode counts, themes, tags, and preview videos.

- **URL**: https://apify.com/spider\_studio/reelshort-landing-page.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 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 Scraper do?

ReelShort Scraper is a **ReelShort API alternative** for collecting trending
short-drama recommendations from [ReelShort](https://www.reelshort.com/). It returns
clean, structured records with titles, book IDs, cover images, synopses, episode
counts, themes, tags, share URLs, and preview video metadata.

Use the results for short-drama discovery, catalog research, trend monitoring,
content analysis, recommendation tracking, or downstream enrichment. Data can be
downloaded as JSON, CSV, Excel, XML, or accessed programmatically through the Apify
API and integrations.

### 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 short drama recommendations?

- Discover trending ReelShort titles and their stable book IDs.
- Monitor how recommendations change across scheduled runs.
- Research popular genres, themes, tropes, and story formats.
- Build title catalogs, dashboards, watchlists, and content databases.
- Enrich analytics or AI workflows with structured short-drama metadata.
- Remove duplicate titles automatically while retaining first-seen order.
- Export results or connect them to Google Sheets, Make, Zapier, webhooks, and other
  Apify integrations.

### What ReelShort data can this scraper extract?

| Field | Type | Description |
| --- | --- | --- |
| `success` | boolean | Whether the recommendation page was collected successfully. |
| `snapshotPage` | integer | Page where the title first appeared. |
| `recommendationGroup` | string | Recommendation group reported by ReelShort. |
| `bookId` | string | ReelShort title identifier. |
| `title` | string | Short-drama title. |
| `subtitle` | string | Subtitle when available. |
| `coverUrl` | string | Cover or thumbnail image URL. |
| `description` | string | Synopsis or promotional description. |
| `chapterCount` | integer | Number of episodes reported by ReelShort. |
| `readCount` | integer | Platform-reported view or read count when available. |
| `themes` | array | Normalized story themes. |
| `tags` | array | Genre, trope, and audience tags. |
| `shareUrl` | string | Public ReelShort sharing URL. |
| `videoId` | string | Preview video identifier when available. |
| `duration` | integer | Preview duration when available. |
| `raw` | object | Additional source fields not covered by the normalized columns. |
| `error` | string or null | Safe error message for an unsuccessful page. |

### How to scrape ReelShort recommendations

1. Open the Actor's **Input** tab.
2. Set **Recommendation pages to scrape**. The default is 5, and the supported range
   is 1–100.
3. Click **Start** and wait for the run to finish.
4. Open the **Output** or **Dataset** tab to review the collected titles.
5. Download the data or connect the Actor to your preferred Apify integration.

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?

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 stored unique ReelShort titles are billed. Failed pages and
duplicate titles are not charged. The final cost therefore depends on the number of
unique results written to the Dataset, not simply the requested page count. Check the
run's **Usage** tab for the exact charge.

### Input

See the Input tab for the complete configuration. The Actor accepts one option:

| Field | Type | Default | Description |
| --- | --- | ---: | --- |
| `pages` | integer | 5 | Number of recommendation pages to collect, from 1 to 100. |

Example input:

```json
{
  "pages": 10
}
```

### Output

You can download the dataset in formats such as JSON, CSV, Excel, XML, RSS, or JSONL.
A typical result looks like this:

```json
{
  "success": true,
  "snapshotPage": 1,
  "recommendationGroup": "recommended",
  "bookId": "35000000001",
  "title": "Example Series",
  "coverUrl": "https://cdn.example.com/example-series.jpg",
  "description": "An example short-drama synopsis.",
  "chapterCount": 60,
  "themes": ["Romance"],
  "tags": ["Second Chance"],
  "shareUrl": "https://www.reelshort.com/example-series",
  "videoId": "45000000001",
  "duration": 120,
  "error": null
}
```

Each dataset row represents one unique ReelShort title. If the same title appears on
multiple requested pages, only its earliest occurrence is retained.

### Tips for better ReelShort data collection

- Use 5 pages for a quick snapshot of current recommendations.
- Use 10–20 pages for broader discovery and market research.
- Schedule recurring runs to compare recommendation changes over time.
- Use `bookId` as the stable key when joining results with other ReelShort datasets.
- Expect results to change between runs because recommendation feeds are dynamic.

### FAQ, disclaimer, and support

#### Does the Actor download ReelShort videos?

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

#### Why can different pages contain the same title?

Recommendation feeds can overlap. The Actor removes duplicate titles from the final
dataset automatically.

#### How fresh are the results?

Each run collects the recommendations available at run time. Schedule the Actor when
you need regular snapshots or change monitoring.

#### Can I use the results through an API?

Yes. Every run and dataset is available through the Apify API, SDKs, CLI, webhooks,
and supported integrations.

> 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

## `pages` (type: `integer`):

Number of ReelShort recommendation pages to collect and merge into one deduplicated dataset.

## Actor input object example

```json
{
  "pages": 5
}
```

# Actor output Schema

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

Parsed and deduplicated short dramas from ReelShort's live For You feed.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/reelshort-landing-page").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("spider_studio/reelshort-landing-page").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 '{}' |
apify call spider_studio/reelshort-landing-page --silent --output-dataset

```

## MCP server setup

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

```

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/XwsF8fIALZf9GB2J2/builds/kNb1FiWp5dpyxI7Y9/openapi.json