# Hongguo Short Drama Release Calendar Scraper API (`spider_studio/hongguo-calendar`) Actor

Scrape Hongguo short drama release calendars by date. Filter live-action dramas or comics; export titles, IDs, covers, episodes, and release times via API.

- **URL**: https://apify.com/spider_studio/hongguo-calendar.md
- **Developed by:** [Tarique](https://apify.com/spider_studio) (community)
- **Stats:** 7 total users, 4 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 unique drama per dates

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?

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

### Hongguo short drama release calendar scraper and API

**Hongguo Short Drama Release Calendar Scraper API** extracts date-based release schedules from [Hongguo Duanju (红果短剧)](https://hongguoduanju.com/). Use this Hongguo release calendar scraper to discover new Chinese short dramas and upcoming titles, filter live-action dramas or comic series, and export readable metadata through the Apify API or Dataset.

Enter one or more dates in `YYYYMMDD` format. Results include **drama titles, series IDs, cover images, release times, categories, and synopses**, with episode counts, scores, and play counts when Hongguo supplies them. Titles stay in their original language. You do not need to provide a Hongguo account or API key.

### What can this Hongguo calendar scraper do?

- Collect the available release calendar for multiple dates in one run.
- Choose all titles, live-action dramas, or comic series with `genre`.
- Monitor upcoming Chinese short dramas and compare daily release snapshots.
- Read titles, covers, IDs, and synopses directly in a flat results table.
- Connect returned `seriesId` values to episode-directory and metadata workflows.
- Export JSON, CSV, Excel, XML, or HTML for dashboards and catalog research.
- Schedule recurring runs and connect the Apify API, webhooks, Make, or n8n.

The Actor collects calendar metadata. Episode directories, media URLs, and authorized video downloads are available through the related Actors below.

### What Hongguo drama data can you extract?

| Field | Type | Description |
| --- | --- | --- |
| `title` | string | Drama title in the source language. |
| `seriesId` | string | Hongguo series ID, preserved as text without rounding. |
| `coverUrl` | string | Cover image URL, shown as a thumbnail in Console. |
| `intro` | string | Drama synopsis. |
| `dramaType` | string | Live-action drama or Comic series, when identified. |
| `releaseStatus` | string | Released, Upcoming, or Unknown. |
| `target_date` | string | Requested calendar date in `YYYYMMDD` format. |
| `scheduledPublishTime` | string or null | Scheduled release time with the China `+08:00` offset. |
| `episodeCount` | integer or null | Reported total episodes. |
| `categories` | array | Drama genres, categories, and tags. |
| `playCount` | integer or null | Reported plays when available. |
| `score` | string or null | Reported drama score. |
| `firstVideoId` | string or null | First episode video ID when supplied. |
| `durationSeconds` | integer or null | Reported total drama duration in seconds. |
| `characters` | array | Character names when supplied. |
| `releaseText` | string or null | Upcoming-title release notice. |
| `raw` | object | Complete original calendar item for reference. |

Upcoming titles often have no episode count, score, or play count yet. Those fields remain null rather than being estimated. The **Drama calendar** view shows the main metadata; **Drama details** adds playback and character fields. **Run diagnostics** contains pagination and quota details, and **Original data** contains `raw`.

### How to scrape Hongguo new releases by date

1. Open the **Input** tab and add one or more dates to **Calendar dates**.
2. Select **All**, **Live-action dramas**, or **Comic series** under **Drama type**.
3. Click **Start** and wait for the calendar requests to finish.
4. Open **Dataset** to inspect drama titles, covers, and release schedules.
5. Download the results or pass the series IDs to another Hongguo Actor.

#### Input example: live-action drama releases

```json
{
  "target_dates": ["2026-10-24"],
  "genre": "shortplay"
}
```

| Input | Required | Description |
| --- | --- | --- |
| `target_dates` | Yes | Non-empty list of valid `YYYY-MM-DD` or `YYYYMMDD` strings. Both formats may be mixed. Duplicate dates are collected once. |
| `genre` | No | `all` for every drama type, `shortplay` for live-action dramas, or `comic_series` for comic series. Defaults to `all`. |

For several dates, use `"target_dates": ["2026-10-24", "2026-10-25", "2026-10-26"]`. Existing `YYYYMMDD` inputs remain supported. Dates are validated, normalized to `YYYYMMDD`, and deduplicated before collection; impossible dates are rejected. The selected drama type applies to every date and page. See the **Input** tab for the complete schema.

### Output: readable Hongguo release-calendar records

Each unique `seriesId` within a requested date becomes one Dataset row. Duplicate items for the same date are omitted before storage and billing; the same series on different requested dates produces separate rows. This simplified example shows the shared field structure for a released title and an upcoming title; full rows also include optional metadata and `raw`.

```json
[
  {
    "title": "Example released drama",
    "seriesId": "7000000000000000001",
    "coverUrl": "https://example.com/cover.jpg",
    "intro": "A story about a fresh start.",
    "dramaType": "Live-action drama",
    "releaseStatus": "Released",
    "target_date": "20261024",
    "scheduledPublishTime": "2026-10-24T10:00:00+08:00",
    "episodeCount": 80,
    "categories": ["Family", "Drama"],
    "playCount": 120000,
    "score": "8.0"
  },
  {
    "title": "Example upcoming drama",
    "seriesId": "7000000000000000002",
    "coverUrl": "https://example.com/upcoming.jpg",
    "intro": "A new adventure begins.",
    "dramaType": "Live-action drama",
    "releaseStatus": "Upcoming",
    "target_date": "20261024",
    "scheduledPublishTime": "2026-10-24T18:00:00+08:00",
    "episodeCount": null,
    "categories": ["Romance"],
    "playCount": null,
    "score": null
  }
]
```

You can download the Dataset in JSON, HTML, CSV, Excel, or XML, or retrieve it from your application through the Apify API.

### Hongguo release-calendar use cases

#### Track new Chinese short dramas and upcoming releases

Schedule the Actor for the dates you monitor and save a release snapshot. Match records by `seriesId` to compare titles and schedules between runs. A calendar snapshot describes the records returned by that session; schedules and availability can change.

#### Build a drama catalog with complete episode lists

Send a released title's `seriesId` to the [Hongguo Series Details & Episodes Scraper API](https://apify.com/spider_studio/hongguo-series-detail) to retrieve its metadata and available episode video IDs. Upcoming titles may not have an episode directory yet.

#### Combine release schedules with search and recommendations

Use the [Hongguo Short Drama Search API](https://apify.com/spider_studio/hongguo-search) for title or keyword lookup, and the [Hongguo Recommendation Feed API](https://apify.com/spider_studio/hongguo-recommend-feed) for discovery beyond a specific release date. This lets you compare date-based availability with search results and recommended titles.

### Related Hongguo short drama Actors

| Actor | Use it for |
| --- | --- |
| [Hongguo Short Drama Search API](https://apify.com/spider_studio/hongguo-search) | Find titles and series IDs by keyword. |
| [Hongguo Recommendation Feed API](https://apify.com/spider_studio/hongguo-recommend-feed) | Discover recommended dramas without choosing a release date. |
| [Hongguo Keyword Suggestions API](https://apify.com/spider_studio/hongguo-search-suggest) | Expand seed terms with autocomplete and related keywords. |
| [Hongguo Series Details & Episodes API](https://apify.com/spider_studio/hongguo-series-detail) | Enrich a released title and retrieve its episode directory. |
| [Hongguo Video Downloader & Decryption to OSS](https://apify.com/spider_studio/hongguo-video-download) | Store authorized episode downloads in S3-compatible object storage. |

### How much does the Hongguo calendar API cost?

Pricing uses the `result` event for each successfully saved **unique drama per requested date**:

| Apify account tier | Price per drama-date result | Price per 1,000 results |
| --- | --- | --- |
| FREE | **$0.004** | **$4.00** |
| BRONZE, SILVER, GOLD, PLATINUM, DIAMOND | **$0.003** | **$3.00** |

Within one run, duplicates are identified by `target_date + seriesId`, including repeated items on the same page or across pages. A drama repeated on one date is saved and charged once. The same drama on two different requested dates is saved and charged twice. Only successfully persisted unique results are charged; duplicate items, empty dates, and diagnostic failure rows are uncharged.

For example, if one date returns A, A, B and another returns A, C, the total is **4 billable results**: two for each date. The result-event fees are **$0.016** on the FREE tier or **$0.012** on a paid tier, plus Apify platform usage. Deduplication applies within the run; rerunning the Actor is a new collection. See the **Pricing** tab for the active pricing configuration.

**Apify platform usage is paid by the user in addition to result-event fees.** Applicable compute, proxy, storage, and data-transfer charges are billed separately by Apify. Empty or failed requests can still incur platform usage even when no result events are charged.

Apify FREE-plan cloud accounts can save up to **100 successful unique drama-date results per UTC calendar month** in this Actor, shared across the requested dates. Paid-plan accounts have no such product quota. If a monthly quota or run charge limit stops collection, the run reports incomplete collection. A monthly-quota stop includes a diagnostic row with the reset time.

### Frequently asked questions

#### Can I query multiple Hongguo release dates at once?

Yes. Add the dates to `target_dates`. Different dates run concurrently, while each date follows its own calendar pages sequentially. The selected `genre` stays the same across every page and retry.

#### Can I get only live-action dramas or only comic series?

Yes. Use `genre: "shortplay"` for live-action dramas or `genre: "comic_series"` for comic series. `genre: "all"` includes every available type. Hongguo applies the filter upstream.

#### Are duplicate dramas charged more than once?

A repeated `seriesId` within the same requested date is counted once per run. The same series appearing on different requested dates is counted once for each date. Duplicate input dates are also collected only once. The monthly FREE-plan quota uses the same deduplicated result count.

#### Does this Actor return every new drama on Hongguo?

It follows pagination until the calendar session reports no more items. The results represent that session's responses, rather than an independently verified total for the entire platform. Empty dates produce no successful rows, and available records can differ between sessions.

#### What happens when one date fails?

Other dates continue. After the date workers finish, a date that still failed after retries makes the run fail. Earlier successful rows remain in the Dataset, so check the final run status before treating an export as complete.

#### Can I get full episode lists or download episodes?

Use the [Hongguo Series Details & Episodes API](https://apify.com/spider_studio/hongguo-series-detail) for episode directories.

#### Can I use this Hongguo API from Python, JavaScript, Make, or n8n?

Yes. The **API** tab provides integration examples; the [Apify API documentation](https://docs.apify.com/api/v2) covers programmatic access. You can start a run with the same JSON input, retrieve its Dataset, or connect schedules and webhooks to your automation workflow.

### Maintainer and support

Actor author and maintainer: <a href="https://apify.com/spider_studio" rel="author">spider_studio</a>. Use the **Issues** tab for support and the **API** tab for programmatic examples. Include the run ID, requested dates, selected drama type, and error message when reporting a problem.

Use calendar data in accordance with Hongguo's terms, applicable law, and your authorization. This Actor collects catalog metadata and does not require access to private Hongguo accounts.

# Actor input Schema

## `target_dates` (type: `array`):

Required list of valid YYYY-MM-DD or YYYYMMDD dates, for example 2026-10-31. Both formats may be mixed. Duplicate dates are collected once. Dates run concurrently; each date is paginated serially.

## `genre` (type: `string`):

Filter all requested dates by drama type: all titles (all), live-action dramas (shortplay), or comic series (comic_series). The same filter is applied to every page.

## Actor input object example

```json
{
  "target_dates": [
    "2026-10-31"
  ],
  "genre": "all"
}
```

# Actor output Schema

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

Titles, series IDs, covers, episode counts, categories, synopsis, and release schedules.

# 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 = {
    "target_dates": [
        "2026-10-31"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/hongguo-calendar").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 = { "target_dates": ["2026-10-31"] }

# Run the Actor and wait for it to finish
run = client.actor("spider_studio/hongguo-calendar").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 '{
  "target_dates": [
    "2026-10-31"
  ]
}' |
apify call spider_studio/hongguo-calendar --silent --output-dataset

```

## MCP server setup

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

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/uvfZIySnXhZBzcyUt/builds/Bj8IKYW7TcjtIBQNt/openapi.json