# Weibo Scraper - Profiles, Posts, Comments & Hot Search (`s-r/weibo-scraper`) Actor

Collect public Weibo profiles, recent posts, top comments and the ranked hot search list. Export text, media links, likes, reposts, follower counts and verification as JSON, CSV or Excel for China brand monitoring and media research.

- **URL**: https://apify.com/s-r/weibo-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 results

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

## Weibo Scraper

Weibo Scraper collects public Weibo profiles, recent posts, comments and the ranked Weibo hot search list for brand monitoring and media research in China. It returns structured records that you can export as JSON, CSV or Excel and join using stable user, post and comment IDs.

Use it to follow a list of brands or creators, inspect individual public posts, read the discussion attached to those posts, or take a snapshot of what is trending on Weibo right now. You can combine these inputs in one run. Keyword search is outside the scope of this actor.

### What the Weibo Scraper returns

Profiles include the account name, biography, follower count, following count, total number of posts and verification information. Posts include plain text, publish time in UTC, likes, comments, reposts and available image or video links. Comments carry their own IDs, the parent post ID, author information, text, publish time and likes. Embedded replies are returned as comment records with a parent comment ID.

The Weibo hot search output includes the ranked list of up to 50 topics, with the topic name, rank, available heat value and public topic URL. A pinned topic has no numerical rank. It is saved separately in the `pinned_topics` key-value record and does not count as a paid dataset row.

| Record type | One row per | Key fields |
|---|---|---|
| `profile` | Weibo account | `profile_id`, `name`, `bio`, `followers`, `following`, `posts_count`, `verified`, `verified_reason` |
| `post` | Public post | `post_id`, `post_url`, `text`, `posted_at`, `likes`, `comments_count`, `shares`, `hashtags`, `images`, `video_url` |
| `comment` | Public comment or embedded reply | `comment_id`, parent post ID, author information, `text`, publish time, likes |
| `trending_topic` | Ranked hot search entry | `topic`, `rank`, `hot_value`, `url`, `query`, `is_hashtag` |

### Use cases for this Weibo scraper

- **Brand monitoring in China.** Follow official brand accounts and competitors, and record follower growth, posting frequency and engagement on each new post.
- **Campaign tracking.** Supply the URLs of campaign posts and collect likes, reposts, comment counts and the top public comments after launch.
- **Media and public-opinion research.** Sample the discussion under news posts, or archive the Weibo hot search list at regular intervals to see which topics rise and fall.
- **Creator and KOL vetting.** Check verification status, follower counts and recent engagement before working with a Weibo creator.
- **Trend dashboards.** Schedule the trending list every hour and load the rows into a spreadsheet, a BI tool or a database through the Apify API.

### Input

Supply `users` as a list of numeric Weibo user IDs or profile URLs. Supported profile forms include `weibo.com/u/<uid>`, `weibo.com/<uid>`, `m.weibo.cn/u/<uid>`, `m.weibo.cn/profile/<uid>` and `/n/<name>` profile URLs. Named URLs are resolved to a numeric account ID. Custom vanity paths are not supported.

Supply `posts` as a list of 16-digit post IDs, 9-character Weibo bids or post URLs. Supported forms include desktop URLs containing the author ID and bid, `/detail/<mid>` URLs and mobile `/status/<mid-or-bid>` URLs. Duplicate references to the same post are collected once. Blank input lines are ignored. Each input list accepts up to 100 entries.

Set `includeTrending` to true to collect the current hot search list. At least one user, post or trending request is required. The example below uses the public Xiaomi account captured in the included research responses.

```json
{"users":["1771925961"],"includeProfile":true,"includePosts":true,"maxPostsPerUser":10,"fullText":true}
```

`includeProfile` and `includePosts` default to true. Disable either when you only need the other kind of record. `includeComments` defaults to false; enable it for comments on both timeline posts and explicitly supplied posts. `maxCommentsPerPost` defaults to 20 and accepts values from 1 to 40. `fullText` defaults to true and requests the full text of long posts when it is publicly available.

`maxPostsPerUser` defaults to 10 and accepts values from 1 to 20. Values above 10 also inspect the first page of original posts, which can add posts absent from the main timeline. `maxItems` limits the combined number of dataset rows across all record types. Its default is 10,000; its maximum is 100,000. A lower total limit can stop collection before every requested record type has been reached.

### Output

Each dataset row has `record_type` and `_type`, identifying `profile`, `post`, `comment` or `trending_topic`. Common fields include `source`, `platform`, `fetched_at`, `input` and a stable `row_id`. The `input` field identifies the supplied entry that produced the record. Retrieval and publish timestamps use UTC.

Profile identifiers are strings in `profile_id`; post identifiers are strings in `post_id`; comment identifiers are strings in `comment_id`. Keeping these identifiers as text avoids spreadsheet rounding. Posts and comments include plain `text` alongside the original `text_html`. Image emoji contribute their text descriptions to the plain-text version. The `hashtags` list on posts contains unique lowercase hashtag names.

Results follow input order: a user's profile, posts and associated comments come first, explicitly requested posts follow, and trending topics come last. The run output also records warnings and a `partial` flag when a requested operation could not finish. Apify follows continuation requests automatically. Direct API clients can forward `next_cursor` as `cursor` while keeping all other input values identical.

#### Example profile row

This is a real row produced from a response collected on 5 October 2026 for the public Xiaomi account.

```json
{
  "record_type": "profile",
  "_type": "profile",
  "row_id": "profile:1771925961",
  "source": "weibo-scraper",
  "platform": "weibo",
  "fetched_at": "2026-10-05T04:10:51.636Z",
  "input": "1771925961",
  "profile_id": "1771925961",
  "profile_url": "https://weibo.com/u/1771925961",
  "handle": "小米公司",
  "name": "小米公司",
  "bio": "让全球每个人都能享受科技带来的美好生活。",
  "followers": 13931000,
  "followers_text": "1393.1万",
  "following": 998,
  "posts_count": 25426,
  "verified": true,
  "verified_type": 2,
  "verified_reason": "小米科技有限责任公司",
  "gender": "m",
  "avatar_url": "https://wx2.sinaimg.cn/orj480/001VUOSZly8gpb1minl2wj60u00u03ze02.jpg",
  "cover_url": "https://wx3.sinaimg.cn/crop.0.0.640.640.640/001VUOSZly1iexk8h8gw9j61o01o0ts402.jpg",
  "mbrank": 6,
  "urank": 48,
  "svip": 0
}
```

#### Example hot search row

A real `trending_topic` row from the Weibo hot search list collected on the same day. Topic names are returned in Chinese, exactly as Weibo shows them.

```json
{
  "record_type": "trending_topic",
  "_type": "trending_topic",
  "row_id": "trending_topic:年轻人开始不买景区冤种三件套了",
  "source": "weibo-scraper",
  "platform": "weibo",
  "fetched_at": "2026-10-05T04:10:51.636Z",
  "input": "trending",
  "topic": "年轻人开始不买景区冤种三件套了",
  "url": "https://m.weibo.cn/search?containerid=100103type%3D1%26t%3D10%26q%3D%23%E5%B9%B4%E8%BD%BB%E4%BA%BA%E5%BC%80%E5%A7%8B%E4%B8%8D%E4%B9%B0%E6%99%AF%E5%8C%BA%E5%86%A4%E7%A7%8D%E4%B8%89%E4%BB%B6%E5%A5%97%E4%BA%86%23&stream_entry_id=31&isnewpage=1&extparam=seat%3D1%26stream_entry_id%3D31%26lcate%3D5001%26realpos%3D1%26flag%3D0%26dgr%3D0%26c_type%3D31%26filter_type%3Drealtimehot%26cate%3D5001%26q%3D%2523%25E5%25B9%25B4%25E8%25BD%25BB%25E4%25BA%25BA%25E5%25BC%2580%25E5%25A7%258B%25E4%25B8%258D%25E4%25B9%25B0%25E6%2599%25AF%25E5%258C%25BA%25E5%2586%25A4%25E7%25A7%258D%25E4%25B8%2589%25E4%25BB%25B6%25E5%25A5%2597%25E4%25BA%2586%2523%26band_rank%3D1%26pos%3D0%26display_time%3D1791171210%26pre_seqid%3D17911712108330405488667&launchid=10000360-page_H5",
  "post_count": null,
  "hot_value": 1160599,
  "label": null,
  "query": "#年轻人开始不买景区冤种三件套了#",
  "is_hashtag": true,
  "rank": 1
}
```

### Public-data limits

Without a login, Weibo shows the first timeline page of an account, generally around ten recent posts. It does not provide a complete historical timeline, even when the account's total post count is much larger. Reading the original-post page can produce additional unique records but does not unlock older pages.

Public comments cover one hot-comment page, generally up to twenty top comments, plus at most two pages of recent comments when a limit above twenty is requested. Overlap is removed. Embedded replies count toward the selected limit. These lists are a sample of the public discussion and may contain fewer comments than requested.

Follower counts above 10,000 are rounded by Weibo. The original display string is included as `followers_text`. Repost and comment counts can be capped at 1,000,000; `counts_capped` flags affected posts. Hot search heat measures search interest, not the number of posts, so `post_count` remains null. Some ranked topics have no available heat value. Media links can expire after collection.

### Weibo scraper compared with other options

- **Copying from the Weibo app or website by hand** works for a few posts, but it does not give you engagement counts in a table, stable IDs or a repeatable schedule.
- **The official Weibo Open Platform** is built for apps that act on behalf of signed-in users and requires a developer application and approval. This actor reads only what is publicly visible and needs no Weibo account.
- **Open-source Weibo crawlers** on GitHub give you full control, but you maintain the parsing, the session handling and the output format yourself whenever Weibo changes. Here you get one documented schema for profiles, posts, comments and trends.
- **Other Weibo scrapers in the Apify Store** differ in scope and price. Some focus on keyword search or a single record type; this actor covers profiles, posts, comments and the hot search list in one run, charges only for delivered rows and has no separate start fee.

### Pricing

The Weibo Scraper charges one result event per delivered dataset row, regardless of record type. Pinned topics, warnings and missing records do not create result events, so an empty run costs nothing in result events. There is no actor start event. Consult the actor's Pricing tab for the active event price before running it; the listing price is controlled there.

Users without a paid Apify plan receive up to ten dataset rows per run. The total row cap includes profiles, posts, comments and ranked topics together. Paid users can select higher limits. A record that cannot be fetched is reported through warnings instead of an artificial dataset row.

### FAQ

#### Can I search posts by keyword?

No. This actor accepts profile references, post references and the trending list. It does not provide keyword search, follower lists or historical timeline traversal.

#### Do I need to provide an account login?

No account login is required for the supported public surfaces. There is no login-cookie input. If Weibo restricts a record, the run reports the restriction and preserves records already collected.

#### Can I use this as a Weibo hot search API?

Yes. Set `includeTrending` to true and leave the user and post lists empty. Each run returns the current ranked hot search list as rows. You can call the actor from the Apify API, schedule it, and read the dataset as JSON or CSV.

#### Why does the returned follower count differ from an exact count?

Weibo rounds large follower counts on its public mobile profile surface. Use `followers_text` to retain the source display, and treat `followers` as the numerical interpretation of that rounded value.

#### Why are fewer comments returned than the post's comment count?

The public comment pages expose selected and recent comments, rather than every comment. The configured maximum is a ceiling. Deleted records, overlap and unavailable public pages can reduce the number delivered.

#### Is the text translated?

No. Posts, comments and topics are returned in the original language, usually Chinese, so that your own translation or sentiment tools see exactly what Weibo users wrote.

# Actor input Schema

## `users` (type: `array`):

Weibo user IDs or profile URLs. Public access returns only the first timeline page. Up to 100 inputs.

## `posts` (type: `array`):

16-digit post IDs, 9-character bids or Weibo post URLs. Up to 100 inputs.

## `includeTrending` (type: `boolean`):

Include the ranked hot-search list; pinned topics are separate and unbilled.

## `includeProfile` (type: `boolean`):

Include profile rows for users.

## `includePosts` (type: `boolean`):

Include recent timeline posts for users.

## `includeComments` (type: `boolean`):

Include comments on returned timeline posts and explicit posts.

## `fullText` (type: `boolean`):

Fetch full text for long posts when public access allows it.

## `maxPostsPerUser` (type: `integer`):

Maximum posts per user. Above 10 also reads the first original-post page; it does not unlock historical timeline pages.

## `maxCommentsPerPost` (type: `integer`):

Maximum comments per post, including embedded replies. Above 20 also reads at most two latest-comment pages. Public access may return fewer.

## `maxItems` (type: `integer`):

Total row limit across all row types and continuation requests. Pinned topics do not count.

## `cursor` (type: `string`):

Opaque next_cursor from an earlier response. Keep all other input fields identical. Apify follows this automatically.

## Actor input object example

```json
{
  "users": [
    "1771925961"
  ],
  "posts": [],
  "includeTrending": false,
  "includeProfile": true,
  "includePosts": true,
  "includeComments": false,
  "fullText": true,
  "maxPostsPerUser": 10,
  "maxCommentsPerPost": 20,
  "maxItems": 10000
}
```

# Actor output Schema

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

One row per delivered profile, post, comment or hot-search topic.

## `output` (type: `string`):

Counts, warnings and delivery status.

# 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 = {
    "users": [
        "1771925961"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/weibo-scraper").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 = { "users": ["1771925961"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/weibo-scraper").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 '{
  "users": [
    "1771925961"
  ]
}' |
apify call s-r/weibo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/weibo-scraper"
        }
    }
}
```

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/R2dBftFwF40ctjsWZ/builds/wMn6b4zT8vG0puzP9/openapi.json