# ReelShort Search Scraper — Short Drama Lookup (`spider_studio/reelshort-search`) Actor

Search ReelShort by title, keyword, trope, or phrase. Get matching short dramas, book IDs, covers, synopses, themes, tags, and recommendations.

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

ReelShort Search Scraper is a **ReelShort API alternative** for finding short dramas
by title, keyword, genre, trope, theme, or phrase. Search
[ReelShort](https://www.reelshort.com/) with up to 1,000 terms in one run and receive
structured title matches and related recommendations.

Results can include ReelShort book IDs, titles, cover images, synopses, episode
counts, themes, tags, share URLs, preview metadata, result positions, and pagination
details. Download the data as JSON, CSV, Excel, XML, RSS, or JSONL, or connect it to
your applications 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 use ReelShort Search Scraper?

- Find ReelShort dramas by exact title or partial phrase.
- Discover titles related to genres, themes, and popular story tropes.
- Search up to 1,000 unique terms in a single run.
- Retrieve stable `bookId` values for catalog and enrichment workflows.
- Separate direct matches from related recommendations.
- Build searchable short-drama catalogs, watchlists, dashboards, and research sets.
- Monitor keywords or title availability with scheduled runs.
- Export results or connect them to Google Sheets, Make, Zapier, webhooks, and other
  Apify integrations.

Typical users include vertical-drama studios, distributors, licensing teams, content
researchers, market analysts, catalog managers, recommendation teams, and developers
building short-drama discovery products.

### What ReelShort search data can this scraper extract?

| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | Search term associated with the result. |
| `success` | boolean | Whether the keyword search completed successfully. |
| `page` | integer | Requested search result page. |
| `limit` | integer | Requested maximum results per keyword. |
| `search` | string | Search text reported with the result. |
| `total` | integer | Total matching titles when available. |
| `returnedCount` | integer | Number of matches and recommendations returned. |
| `resultType` | string | `match` or `recommendation`. |
| `position` | integer | Position within the result group. |
| `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 normalized columns. |
| `error` | string or null | Error message for an unsuccessful keyword. |

### How to search ReelShort short dramas

1. Open the Actor's **Input** tab.
2. Add one or more titles, genres, tropes, themes, or phrases under **Search
   keywords**.
3. Choose the result **Page** and **Results per page**.
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 searches and retrieve results through
the Apify API, SDKs, CLI, webhooks, or MCP integrations.

### How much does it cost to search 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 ReelShort title results are billed. Failed keywords and
searches that return no titles are not charged. Check each run's **Usage** tab for
the exact charge.

### Input

See the Input tab for the complete configuration.

| Field | Type | Required | Default | Description |
| --- | --- | --- | ---: | --- |
| `keywords` | array of strings | Yes | — | Up to 1,000 titles, genres, tropes, or phrases. |
| `page` | integer | No | 1 | Result page requested for every keyword. |
| `limit` | integer | No | 10 | Maximum results requested per keyword, from 1 to 50. |

Whitespace is removed from search terms, empty values are rejected, and duplicate
keywords are ignored.

Example input:

```json
{
  "keywords": [
    "billionaire romance",
    "werewolf",
    "second chance"
  ],
  "page": 1,
  "limit": 20
}
```

### Output

You can download the dataset in formats such as JSON, CSV, Excel, HTML, XML, RSS, or
JSONL. Each matched or recommended ReelShort title is returned as a separate row.

```json
{
  "keyword": "billionaire romance",
  "page": 1,
  "limit": 20,
  "success": true,
  "resultType": "match",
  "position": 1,
  "total": 42,
  "returnedCount": 20,
  "bookId": "35000001234",
  "title": "Example Series",
  "coverUrl": "https://cdn.example.com/example-series.jpg",
  "description": "An example short-drama synopsis.",
  "chapterCount": 60,
  "themes": ["Romance"],
  "tags": ["Billionaire", "Second Chance"],
  "error": null
}
```

If a keyword returns no titles, no billable Dataset row is created for that keyword.
The run status and logs still report completed and failed searches.

### Tips for better ReelShort title search

- Use the exact title when checking whether a specific drama exists.
- Try both broad and specific phrases for content discovery.
- Search individual tropes such as `revenge`, `secret identity`, or `contract
  marriage` to explore related titles.
- Use `bookId` as the stable key when joining search data with other datasets.
- Increase `limit` before moving to later pages when you want broader coverage.
- Schedule recurring searches to monitor newly appearing titles and keyword trends.

### FAQ, disclaimer, and support

#### Can I search multiple ReelShort titles at once?

Yes. Add up to 1,000 unique search terms to `keywords`. Results retain the keyword
that produced each row.

#### What is the difference between a match and a recommendation?

A `match` is returned as a direct search result. A `recommendation` is a related title
suggested alongside the search results.

#### Why did a keyword return zero results?

The title may use different spelling, punctuation, translation, or wording. Try a
shorter phrase, a character name, or a related genre or trope.

#### Does the Actor download ReelShort videos?

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

#### How fresh are the search results?

Each run searches the titles available at run time. Schedule recurring runs when you
need ongoing monitoring.

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

Yes. Runs and datasets are 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

## `keywords` (type: `array`):

Titles, genres, tropes, themes, or phrases to search for on ReelShort. Duplicate entries are ignored.

## `page` (type: `integer`):

One-based search result page to collect for every keyword.

## `limit` (type: `integer`):

Maximum number of short-drama results requested for each keyword.

## Actor input object example

```json
{
  "keywords": [
    "love",
    "billionaire"
  ],
  "page": 1,
  "limit": 10
}
```

# Actor output Schema

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

One structured row per matched or recommended ReelShort short drama.

# 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 = {
    "keywords": [
        "love",
        "billionaire"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/reelshort-search").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 = { "keywords": [
        "love",
        "billionaire",
    ] }

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

```

## MCP server setup

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

```

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/4qKAqoVURP8R3xv0P/builds/He6APE96xkGKhnXxf/openapi.json