# China Upcoming Movies & Most Anticipated Films (Maoyan) (`sinodata/china-movie-wishlist`) Actor

China upcoming movies and most-anticipated films from Maoyan (猫眼), no login: want-to-see (想看) counts, release dates, cast, anticipation rank and growth since your last run. Forecast box office before release.

- **URL**: https://apify.com/sinodata/china-movie-wishlist.md
- **Developed by:** [SinoData](https://apify.com/sinodata) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 films

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## China Upcoming Movies & Most Anticipated Films (Maoyan)

See **which upcoming films Chinese audiences want to see most**, before they open. Data comes from **Maoyan (猫眼)**, China's largest movie ticketing platform. No login, no browser.

- **Every upcoming release** in China (about 100 films) with release date, cast and the **want-to-see count (想看)**
- **Maoyan's most-anticipated ranking (最受期待)**, merged into the same records, including big titles without a date yet
- **Growth tracking**: the change in want-to-see since your last run, and the change per day
- **Film details** (optional): genres, directors, duration, country, release note

Want-to-see counts are the best public early signal for Chinese box office: they grow fast in the weeks before a hit opens.

### Use cases

- **Box-office forecasting**: track want-to-see growth for every upcoming film and compare it with opening weekends.
- **Studios, distributors and marketers**: measure campaign impact day by day, and benchmark against competing releases.
- **Investors**: early demand signals for Chinese and Hollywood titles released in China.
- **Media and fans**: release calendar for China with real interest numbers.
- **New-release alerts**: schedule a daily run with "Only films new since the last run" to catch newly announced releases.

### Example input

```json
{
  "lists": ["upcoming", "mostExpected"],
  "sortBy": "wishCount",
  "minWishCount": 1000,
  "maxMovies": 100,
  "compareWithLastRun": true
}
```

### Output

One record per film:

```json
{
  "type": "movie",
  "movieId": "1500516",
  "title": "恐怖直播",
  "releaseDate": "2026-10-08",
  "releaseLabel": "10月8日 周四",
  "wishCount": 15562,
  "anticipationRank": 23,
  "inUpcomingList": true,
  "stars": ["丁一帆", "李雪嫚", "贺金雪"],
  "score": null,
  "preShow": false,
  "listStatus": "seen before",
  "previousWishCount": 14010,
  "wishChange": 1552,
  "wishChangePerDay": 1552,
  "genres": ["惊悚", "恐怖"],
  "directors": ["孟鑫"],
  "durationMin": 90,
  "country": "中国大陆",
  "url": "https://www.maoyan.com/films/1500516"
}
```

- `releaseDate` is null when the film has no exact date yet; `releaseLabel` then says e.g. `2026年 待定` (2026, date to be announced).
- `anticipationRank` is the film's position in Maoyan's most-anticipated ranking (null if it isn't ranked).
- `score` is the Maoyan audience score once there is one (early screenings), otherwise null.
- Titles and names are kept in Chinese as published.
- Detail fields (`genres`, `directors`, `durationMin`, `country`, `releaseNote`, `englishTitle`, `watchedCount`, `ratingCount`) appear only with **Include film details**.

### Monitoring

With **Compare with the last run** (on by default) each film gets `previousWishCount`, `wishChange`, `wishChangePerDay` and `listStatus` (`new`, `seen before` or `first run`). The memory is kept in your Apify account between runs. Schedule a daily run to build a want-to-see history for every film.

### Pricing

**$0.002 per film.** All upcoming films (about 100) cost about $0.20 per run; a daily run for a month costs about $6.

### Notes and limits

- Maoyan limits how many film-detail pages it answers. Details are fetched slowly for the first films only (20 by default); if Maoyan asks for verification, the run keeps saving every film without details and says so in the log.
- Want-to-see counts are national (they don't depend on the city).
- Only public data is collected.

### Related

- [China Box Office](https://apify.com/sinodata/china-box-office): daily box office for every film in cinemas, including presale figures for coming days.

### Feedback

Need another field or list? Open an issue on the Issues tab.

# Actor input Schema

## `lists` (type: `array`):

upcoming = every film with a scheduled release in China (about 100); mostExpected = Maoyan's most-anticipated ranking (about 100, including films without a date yet). Both are merged into one record per film.

## `sortBy` (type: `string`):

Order of the saved films.

## `minWishCount` (type: `integer`):

Skip films with fewer people who want to see them.

## `maxMovies` (type: `integer`):

How many films to save (after sorting and filtering).

## `includeDetails` (type: `boolean`):

Add genres, directors, duration, country, release note and watched count. Fetched slowly, one film at a time, so keep the limit below small.

## `maxDetails` (type: `integer`):

Details are fetched for the first N saved films. Maoyan limits how many it answers; the run stops fetching details (but still saves every film) if Maoyan asks for verification.

## `compareWithLastRun` (type: `boolean`):

Add the previous want-to-see count, the change and the change per day since your last run, using a memory kept in your account between runs.

## `onlyNewMovies` (type: `boolean`):

Save (and pay for) only films that were not in the lists last time, e.g. newly announced releases. The first run saves everything.

## `memoryName` (type: `string`):

Use different names to keep separate histories (for example one per scheduled task).

## `proxyConfiguration` (type: `object`):

Not needed for normal use.

## Actor input object example

```json
{
  "lists": [
    "upcoming",
    "mostExpected"
  ],
  "sortBy": "wishCount",
  "minWishCount": 0,
  "maxMovies": 200,
  "includeDetails": false,
  "maxDetails": 20,
  "compareWithLastRun": true,
  "onlyNewMovies": false,
  "memoryName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `results` (type: `string`):

No description

# 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("sinodata/china-movie-wishlist").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("sinodata/china-movie-wishlist").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 sinodata/china-movie-wishlist --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sinodata/china-movie-wishlist"
        }
    }
}
```

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/fQtynaGB3HeKvIh5Z/builds/aITZMkTVX0Sng69Px/openapi.json