# China Trending Topics: Weibo Douyin Baidu Toutiao Bilibili (`praguedatalab/china-trending-topics`) Actor

China trending topics from Weibo, Douyin, Baidu, Toutiao and Bilibili in one call: rank, hot value, label, topic link, one schema, new/rising/falling tracking between runs. No login. $3 per 1,000.

- **URL**: https://apify.com/praguedatalab/china-trending-topics.md
- **Developed by:** [Prague Data Lab](https://apify.com/praguedatalab) (community)
- **Categories:** Social media, News, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 trending topics

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Trending Topics API (Weibo, Douyin, Baidu, Toutiao, Bilibili)

**China trending topics from Weibo, Douyin, Baidu, Toutiao and Bilibili in one call: one row per topic with platform, board, rank, the original Chinese title, hot value, label (hot / new / boom) and a link, in one schema for all five platforms. No login, no cookies, no proxy needed, $3 per 1,000 topics.**

```json
{ "platforms": ["weibo", "douyin", "baidu", "toutiao", "bilibili"], "maxItemsPerPlatform": 10 }
```

Three output rows (long values shortened, snapshot of 20 Oct 2026):

```json
{
    "type": "trend",
    "platform": "douyin",
    "platformName": "抖音",
    "board": "hot",
    "boardName": "热点榜",
    "rank": 1,
    "word": "中国队夺拜仁青年杯冠军",
    "url": "https://www.douyin.com/hot/2703074",
    "hotValue": 11741271,
    "label": "hot",
    "labelName": "热",
    "category": null,
    "description": null,
    "imageUrl": "https://p5-ex-gddgtc-sign.douyinpic.com/tos-cn-p-0015c000-ce/oolEYEfEnw1Q…~noop.jpeg",
    "topicId": "2703074",
    "isAd": false,
    "isPinned": false,
    "videoCount": 1,
    "eventAt": "2026-10-19T09:21:11.000Z",
    "snapshotAt": "2026-10-20T06:10:00.000Z",
    "firstSeenAt": null,
    "minutesOnBoard": null
}
```

```json
{
    "type": "trend",
    "platform": "baidu",
    "platformName": "百度",
    "board": "realtime",
    "boardName": "热搜榜",
    "rank": 1,
    "word": "披旭日旗的中国留学生已被遣返开除",
    "url": "https://www.baidu.com/s?wd=%E6%8A%AB%E6%97%AD%E6%97%A5%E6%97%97…",
    "hotValue": 7809798,
    "label": "hot",
    "labelName": "热",
    "category": null,
    "description": "近日，一名陈姓中国留学生在莫斯科大学历史系课堂身披日本军国主义旭日旗引发…",
    "imageUrl": "https://fyb-2.cdn.bcebos.com/hotboard_image/079871afd7f038bb5ed70f23ac1c022d",
    "topicId": null,
    "isAd": false,
    "isPinned": false,
    "videoCount": null,
    "eventAt": null,
    "snapshotAt": "2026-10-20T06:10:00.000Z",
    "firstSeenAt": null,
    "minutesOnBoard": null
}
```

```json
{
    "type": "trend",
    "platform": "bilibili",
    "platformName": "哔哩哔哩",
    "board": "search",
    "boardName": "热搜",
    "rank": 1,
    "word": "英伟达称消费级GPU短缺已失控",
    "url": "https://search.bilibili.com/all?keyword=%E8%8B%B1%E4%BC%9F%E8%BE%BE…",
    "hotValue": 788145,
    "label": "hot",
    "labelName": "热",
    "category": null,
    "description": null,
    "imageUrl": null,
    "topicId": null,
    "isAd": false,
    "isPinned": false,
    "videoCount": null,
    "eventAt": null,
    "snapshotAt": "2026-10-20T06:10:00.000Z",
    "firstSeenAt": null,
    "minutesOnBoard": null
}
```

### What you get

Everything comes from the public hot boards of each platform, the same lists the apps and websites show to a visitor who is not signed in. A full run of the five default boards takes about 10 seconds.

| Platform | Default board | Other boards (optional) | `hotValue` is | Also in the row |
|---|---|---|---|---|
| **Weibo** 微博 | `realtime` 热搜榜 (50 topics + the pinned one) | `entertainment` 文娱榜, `news` 要闻榜 | Weibo heat score (热度). Realtime top is between a few hundred thousand and over a million | category, Weibo's own first-seen time on the realtime board |
| **Douyin** 抖音 | `hot` 热点榜 (about 50 topics) | `rising` 实时上升热点 (5 fast climbers, no hot value) | Douyin hot value (热度值). Top is about 11 million | topic ID, video count, event time, cover |
| **Baidu** 百度 | `realtime` 热搜榜 (50 topics) | `livelihood`, `finance`, `sports`, `new_entertainment`, `internation_news`, `challenge`, `movie`, `teleplay`, `novel`, `car`, `game` | Baidu hot score (热搜指数). Realtime top is about 7.8 million; movie, TV, novel and game boards use a smaller scale (about 100,000) | summary text, cover |
| **Toutiao** 今日头条 | `hot` 热榜 (50 topics + the pinned one) | | Toutiao hot value. Top is about 27 million | topic ID, interest category, cover |
| **Bilibili** 哔哩哔哩 | `search` 热搜 (50 trending search keywords) and `ranking` 全站榜 (100 top videos) | | `search`: heat score (about 0.8 million at the top). `ranking`: **view count** of the video | `ranking`: BV id as topic ID, cover |

Hot values use a different scale on every platform: compare ranks and changes inside a platform, not raw values across platforms.

### Use cases

- **Brands and agencies selling in China:** see within the hour when your brand, a competitor or a category reaches a hot board, which platform picked it up first and how long it stays.
- **Media and newsrooms:** one table of what China is talking about right now, with what the platforms pin to the top.
- **Analysts and researchers:** an hourly time series of attention (rank, hot value, label) across five platforms for sentiment, consumer-trend or political-communication studies.
- **AI agents:** one cheap call returns a structured, deduplicated snapshot of China's trending topics with links.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `platforms` | array | all five | `weibo`, `douyin`, `baidu`, `toutiao`, `bilibili`. |
| `maxItemsPerPlatform` | integer | `20` | Top N rows kept per platform (1 to 200); each row is one charged event. With several boards on one platform the top of every board comes first (Bilibili default: `search` and `ranking` share N, so 10 gives 5 + 5). A pinned topic counts as a row. |
| `deltaMode` | boolean | `false` | Tag each topic `new`, `rising`, `falling` or `steady` versus the previous run with the same delta key. |
| `deltaStateKey` | string | `default` | Name of an independent tracking stream (e.g. `hourly`). Kept in your key-value store `china-trending-state`. |
| `includePromoted` | boolean | `false` | Weibo sells one slot on the realtime board, and Douyin marks sponsored slots with a 商 badge. Dropped before billing by default; with `true` they are returned with `isAd: true`. |
| `weiboBoards` | array | `["realtime"]` | `realtime`, `entertainment`, `news`. |
| `douyinBoards` | array | `["hot"]` | `hot`, `rising`. |
| `baiduBoards` | array | `["realtime"]` | `realtime`, `livelihood`, `finance`, `sports`, `new_entertainment`, `internation_news`, `challenge`, `movie`, `teleplay`, `novel`, `car`, `game`. |
| `bilibiliBoards` | array | `["search", "ranking"]` | `search`, `ranking`. |
| `proxyConfiguration` | object | none | Optional Apify Proxy. Not needed today. |

Titles stay in the original Chinese: translation is not part of this Actor. Pipe the `word` column to a translation API or an LLM downstream if you need it.

### Output fields

One row per topic per snapshot. Every field is also in the dataset schema.

| Field | Description |
|---|---|
| `type` | Always `trend` (also the name of the charged event). |
| `platform`, `platformName` | `weibo`, `douyin`, `baidu`, `toutiao` or `bilibili`, and its Chinese name. |
| `board`, `boardName` | Board key (see the table above) and the board's name as the platform shows it. |
| `rank` | Position on the board, 1 = top. `null` for the topic the platform pins above the board, and for Weibo's paid slot. |
| `word` | Topic text in Chinese, without `#` marks. On the Bilibili `ranking` board: the video title. |
| `url` | Link to the topic: Weibo, Baidu and Bilibili search page, Douyin hot page, Toutiao trending page, Bilibili video. |
| `hotValue` | Heat score as the platform publishes it, `null` when it publishes none (Douyin `rising`, the pinned topics, Baidu when only the mobile list answers). Bilibili `ranking`: view count. |
| `label` | `hot`, `new`, `boom` or `none`. |
| `labelName` | The badge as the platform shows it (热, 新, 爆, 沸, 热议, 独家, 首发, 挑战, 梗, 解读, 辟谣…), `null` when there is none. |
| `category` | Weibo category (民生新闻, 艺人…), Toutiao interest category (`international`, `sports`…), Bilibili video partition when available; `null` otherwise. |
| `description` | Short summary text (Baidu). |
| `imageUrl` | Cover image of the topic or video, when the platform gives one. |
| `topicId` | The platform's own ID: Douyin `sentence_id`, Toutiao cluster ID, Bilibili BV id on `ranking`. `null` where the platform has none. |
| `isAd`, `isPinned` | Paid slot (only with `includePromoted`); topic pinned above the board. |
| `videoCount` | Douyin: number of videos under the topic. |
| `eventAt` | Douyin: time of the event behind the topic. ISO 8601 UTC. |
| `snapshotAt` | Time of the snapshot, ISO 8601 UTC. The same for every row of a run. |
| `firstSeenAt`, `minutesOnBoard` | When the topic entered the board: Weibo's own time on the realtime board, or the first run of the delta key that saw it (`deltaMode`). Minutes since then. |
| `status`, `previousRank`, `rankDelta`, `hotValueDelta`, `peakRank`, `peakHotValue` | `deltaMode` only: see below. |

### Track movement: hourly snapshots with `deltaMode`

The Actor returns snapshots. To see movement, schedule it:

1. Create a task with `{ "platforms": ["weibo", "douyin", "baidu", "toutiao", "bilibili"], "maxItemsPerPlatform": 10, "deltaMode": true, "deltaStateKey": "hourly" }`.
2. In Apify Console go to **Schedules → Create new**, cron `0 * * * *` (every hour), and add the task.
3. Every run stamps its rows with `snapshotAt`. Collect them with an integration (Google Sheets, webhook, Make, Zapier) or the API (`GET /v2/actor-tasks/{taskId}/runs`, then each run's `defaultDatasetId` items) and group by `platform`, `board`, `word` and `snapshotAt` to chart rank and hot value over time.
4. With `deltaMode` every row also says how it moved since the previous run of the same key: `status` is `new`, `rising`, `falling` or `steady`; `previousRank` and `rankDelta` (positive = climbed); `hotValueDelta`; `firstSeenAt` and `minutesOnBoard`; `peakRank` and `peakHotValue` (best seen on that board). The first run of a key is the baseline: every topic is `new`.

Use one `deltaStateKey` per schedule. Movement is computed on the full board (about 50 topics, 100 videos for the Bilibili ranking) before `maxItemsPerPlatform` is applied, so a topic entering your top 10 from rank 11 shows `rising`, not `new`. Topics that left a board are not returned as rows. Tracking history is kept for a week per topic.

Cost of an hourly snapshot: the prefill above is 50 rows × $0.003 = **$0.15 per run**, about $108 a month. Fewer rows or fewer platforms cost proportionally less.

### When a platform is down

A platform, or one board of a platform, that cannot be read (blocked, changed, timing out) is skipped: the run continues with the others, charges only for the rows it delivers, and the final status message names what was skipped and why, for example:

> 40 trending topics saved (weibo: 10, baidu: 10, toutiao: 10, bilibili: 10). Skipped: douyin (HTTP 503 from www.douyin.com).

Baidu and Bilibili have a built-in second source: Baidu falls back to its mobile list (same ranking, no hot value) and each Bilibili board has a second endpoint. If nothing could be read, the run ends with a status message and an empty dataset, without a crash.

### Pricing

**$3 per 1,000 topics** ($0.003 per row, pay per result). No platform-usage charge on top. The run stops cleanly when the maximum cost you set is reached. With several platforms the rows are delivered one rank at a time across platforms (all rank 1s, then all rank 2s…), so a cost cap keeps a fair mix instead of only the first platform.

### Good to know

- **Public data, no login.** Only the public hot boards are read. No accounts, cookies or personal data of private individuals are involved: rows are topics, keywords and, on the Bilibili ranking, public videos.
- **Not covered, because they need a login or a signed request:** Zhihu hot list, Kuaishou, RedNote (Xiaohongshu), Douyin search, Taobao. Weibo posts of verified accounts per topic: use the sister Actor *Weibo Hot Search Scraper*.
- **The platforms change their pages without notice.** The Actor has fallbacks where a second source exists and tells you in the status message when something was skipped.
- **Bilibili ranking:** the site's newer `ranking/v2` endpoint refuses datacenter IPs, so the Actor reads the classic ranking endpoint (100 videos, ranked over the last 3 days) and only tries `ranking/v2` if the classic one stops answering.
- **Timestamps** are ISO 8601 in UTC. Platforms publish in Beijing time (UTC+8); the Actor converts.

### FAQ

**Can I get the Chinese titles translated?** Not here. Keep `word` as the join key and translate downstream.

**Why do I get fewer rows than `maxItemsPerPlatform` × platforms?** Boards can be shorter than the cap (Douyin about 50, `rising` 5), a platform can be skipped (see the status message), and paid slots are dropped unless `includePromoted` is on.

**Why is Bilibili split in two?** Its two default boards (`search` and `ranking`) share the platform's N. Set `bilibiliBoards` to `["search"]` for 10 trending keywords only.

**How fresh is the data?** The platforms refresh their boards every few minutes. An hourly schedule is a good default.

# Actor input Schema

## `platforms` (type: `array`):

Which platforms to read. A platform that is unreachable is skipped and named in the run's status message; the others are still delivered.

## `maxItemsPerPlatform` (type: `integer`):

Top N topics kept per platform (each row is one charged event). With several boards on one platform the top of every board is kept first. 20 topics on 5 platforms = 100 rows.

## `deltaMode` (type: `boolean`):

Tag every topic <code>new</code>, <code>rising</code>, <code>falling</code> or <code>steady</code> versus the previous run with the same delta key, with rank change, hot-value change, first-seen time and running peaks. The first run of a key sets the baseline (every topic is <code>new</code>).

## `deltaStateKey` (type: `string`):

Name of an independent tracking stream for deltaMode (e.g. <code>hourly</code>, <code>brand-x</code>). The state is kept in your key-value store <code>china-trending-state</code>.

## `includePromoted` (type: `boolean`):

Weibo sells one slot on its realtime board. Off (default): it is removed before billing. On: it is returned flagged <code>isAd: true</code> with no rank.

## `weiboBoards` (type: `array`):

<b>realtime</b> 热搜榜 (the main board), <b>entertainment</b> 文娱榜, <b>news</b> 要闻榜.

## `douyinBoards` (type: `array`):

<b>hot</b> 热点榜 (the main hot-search list) and <b>rising</b> 实时上升热点 (the few topics climbing fast; no hot value).

## `baiduBoards` (type: `array`):

<b>realtime</b> 热搜榜 is the main board. The others are Baidu's topic boards: livelihood 民生, finance 财经, sports 体育, entertainment 文娱, international 国际, challenge 挑战, movie 电影, teleplay 电视剧, novel 小说, car 汽车, game 游戏.

## `bilibiliBoards` (type: `array`):

<b>search</b> 热搜 (trending search keywords) and <b>ranking</b> 全站榜 (top videos of the site; the hot value is the view count).

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

Optional. The boards answer datacenter IPs without a proxy today; enable Apify Proxy only if runs start failing.

## Actor input object example

```json
{
  "platforms": [
    "weibo",
    "douyin",
    "baidu",
    "toutiao",
    "bilibili"
  ],
  "maxItemsPerPlatform": 10,
  "deltaMode": false,
  "deltaStateKey": "default",
  "includePromoted": false,
  "weiboBoards": [
    "realtime"
  ],
  "douyinBoards": [
    "hot"
  ],
  "baiduBoards": [
    "realtime"
  ],
  "bilibiliBoards": [
    "search",
    "ranking"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `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 = {
    "platforms": [
        "weibo",
        "douyin",
        "baidu",
        "toutiao",
        "bilibili"
    ],
    "maxItemsPerPlatform": 10,
    "deltaMode": false,
    "deltaStateKey": "default",
    "includePromoted": false,
    "weiboBoards": [
        "realtime"
    ],
    "douyinBoards": [
        "hot"
    ],
    "baiduBoards": [
        "realtime"
    ],
    "bilibiliBoards": [
        "search",
        "ranking"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("praguedatalab/china-trending-topics").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 = {
    "platforms": [
        "weibo",
        "douyin",
        "baidu",
        "toutiao",
        "bilibili",
    ],
    "maxItemsPerPlatform": 10,
    "deltaMode": False,
    "deltaStateKey": "default",
    "includePromoted": False,
    "weiboBoards": ["realtime"],
    "douyinBoards": ["hot"],
    "baiduBoards": ["realtime"],
    "bilibiliBoards": [
        "search",
        "ranking",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("praguedatalab/china-trending-topics").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 '{
  "platforms": [
    "weibo",
    "douyin",
    "baidu",
    "toutiao",
    "bilibili"
  ],
  "maxItemsPerPlatform": 10,
  "deltaMode": false,
  "deltaStateKey": "default",
  "includePromoted": false,
  "weiboBoards": [
    "realtime"
  ],
  "douyinBoards": [
    "hot"
  ],
  "baiduBoards": [
    "realtime"
  ],
  "bilibiliBoards": [
    "search",
    "ranking"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call praguedatalab/china-trending-topics --silent --output-dataset

```

## MCP server setup

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

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/rrWl0zPr07sqMDFF7/builds/1wv6QwAhEePopKMfB/openapi.json