# Weibo Comments Scraper - 微博评论 Comments & Replies (`hgservices/weibo-comments-scraper`) Actor

Scrape comments and replies from Weibo (微博) posts by URL. Get comment text, author, followers, likes, time and IP region (IP属地). No login or cookies needed.

- **URL**: https://apify.com/hgservices/weibo-comments-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 saved comments

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

Scrape the **comments and replies of Weibo (微博) posts**. Give post URLs, and get each comment with its **text, time, likes, IP region (IP属地)** and **author** (name, verification, followers and avatar), plus the **replies** under it.

**No Weibo account, login or cookies are needed.** Download the data as JSON, CSV or Excel, run the Actor from the API on a schedule, or ask an AI assistant such as Claude or ChatGPT to get Weibo comments for you.

### What does Weibo Comments Scraper do?

It reads the public comment section of each Weibo post that you give it. You get one row for each **top-level comment**, and the replies to that comment are in the same row.

For each comment you get:

- **Comment:** ID, text, publish time and likes
- **Author:** user ID, name, profile URL, verification and its reason (认证), followers and avatar
- **IP region:** the province or country that Weibo shows under the comment (IP属地, for example `四川` or `英国`)
- **Replies:** the number of replies that Weibo counts, and the replies themselves. Each reply has its text, time, author, likes, IP region and the name of the user it answers
- **Post:** the ID and URL of the post, so you can scrape many posts in one run

By default, each comment has the first replies that Weibo sends with it. Turn on **Include full reply threads** to get the reply threads of comments that have more replies.

Because it runs on the Apify platform, you also get API access, scheduling, integrations, proxy rotation and run monitoring.

### Why scrape Weibo comments?

Weibo is one of China's largest social networks. Its comment sections show how Chinese users react to brands, celebrities, news and products in real time.

- **Sentiment analysis:** collect the reactions to a product launch, an ad campaign or a public statement.
- **Brand and crisis monitoring:** track what users say under the posts of a brand, a competitor or a key opinion leader (KOL).
- **Regional insight:** use the IP region of each comment to see where the reactions come from.
- **Fan and community research:** study the fan communities of celebrities, shows and games.
- **AI and NLP datasets:** build dated, attributed corpora of informal Chinese text with engagement numbers.

### How to scrape Weibo comments

1. Open a Weibo post in your browser and copy its URL.
2. Paste one or more URLs into **Post URLs**.
3. Set **Max comments per post**. The default is 100, and `0` gets all the comments that Weibo shows.
4. Optional: turn on **Include full reply threads**.
5. Click **Start** and wait for the run to finish.
6. Open the **Output** tab to see the comments, or export them as JSON, CSV, Excel, XML or HTML.

### Input

Configure the run on the **Input** tab, or send the input as JSON.

| Field | What it does | Example |
|-------|--------------|---------|
| **Post URLs** | Weibo post URLs or post IDs. These formats work: `weibo.com/{user}/{post}`, `weibo.com/detail/{id}`, `m.weibo.cn/detail/{id}`, `m.weibo.cn/status/{id}` and bare IDs | `["https://weibo.com/2902408801/RluBSdMAw"]` |
| **Max comments per post** | The most top-level comments to save for each post. Replies do not count. `0` = all that Weibo shows | `100` |
| **Include full reply threads** | Gets the full reply thread of each comment that has more replies than Weibo sends with it. It does not change which comments you get or how many | `false` |

#### Example: the top 50 comments of one post

```json
{
  "postUrls": ["https://weibo.com/2902408801/RluBSdMAw"],
  "maxResults": 50
}
```

#### Example: all visible comments with full reply threads

```json
{
  "postUrls": [
    "https://weibo.com/2902408801/RluBSdMAw",
    "https://m.weibo.cn/detail/5351830879994049"
  ],
  "maxResults": 0,
  "includeAllReplies": true
}
```

### Output

You get one row for each top-level comment. Here is a row from a real run (the reply list is shortened to one reply):

```json
{
  "id": "5351241208299990",
  "postId": "5351225563285040",
  "postUrl": "https://weibo.com/2902408801/RluBSdMAw",
  "text": "圖8超美[鲜花]",
  "createdAt": "2026-10-07T04:33:08+08:00",
  "author": {
    "id": "1795913557",
    "name": "沈芷凝",
    "url": "https://weibo.com/u/1795913557",
    "verified": true,
    "verifiedReason": "编剧，作品：《又见一帘幽梦》《丝丝心动》《藏心术》《美人无泪》《倾城雪》",
    "followersCount": 311150,
    "avatarUrl": "https://tvax1.sinaimg.cn/crop.0.0.1080.1080.1024/6b0b7755ly8i7oxshc46ij20u00u0wkf.jpg?KID=imgbed,tva&Expires=1791527776&ssig=lOzgvgVSuD"
  },
  "likesCount": 432,
  "location": "英国",
  "replyCount": 3,
  "replies": [
    {
      "id": "5351358226239293",
      "text": "哈哈哈，我也喜欢🥰",
      "createdAt": "2026-10-07T12:18:07+08:00",
      "author": {
        "id": "7636373980",
        "name": "V-吼吼-",
        "url": "https://weibo.com/u/7636373980",
        "verified": false,
        "verifiedReason": null,
        "followersCount": 0,
        "avatarUrl": "https://tvax2.sinaimg.cn/crop.0.0.1080.1080.1024/008kNrIgly8ifs3y0b18kj30u00u0423.jpg?KID=imgbed,tva&Expires=1791527776&ssig=MXK2Flkviy"
      },
      "likesCount": 48,
      "location": "江苏",
      "replyToCommentId": "5351241208299990",
      "replyToName": "沈芷凝"
    }
  ],
  "scrapedAt": "2026-10-09T03:36:18+00:00"
}
```

The **Output** tab shows the comments in a table with the time, author, text, likes, replies, IP region and post link. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
|-------|-------------|
| `id` | Comment ID |
| `postId` / `postUrl` | ID and link of the post |
| `text` | Comment text. Weibo emoji show as `[name]`, for example `[鲜花]` |
| `createdAt` | Publish time, ISO 8601, China time (UTC+8) |
| `author` | `id`, `name`, `url`, `verified`, `verifiedReason`, `followersCount`, `avatarUrl` |
| `likesCount` | Likes on the comment |
| `location` | The IP region that Weibo shows (IP属地): a Chinese province or a country. Replies from Weibo's AI accounts show a label instead |
| `replyCount` | The number of replies that Weibo counts for the comment |
| `replies` | The replies: `id`, `text`, `createdAt`, `author`, `likesCount`, `location`, `replyToCommentId`, `replyToName` |
| `scrapedAt` | When your run collected the row (UTC) |

### How to use Weibo Comments Scraper

#### In Apify Console

1. Open the Actor, fill in the **Input** tab and click **Start**.
2. Watch the run's progress in the log, then open the **Output** tab.
3. Click **Save as a new task** to run the same setup again with one click. On the task, add a **Schedule** to collect new comments every day or week.

#### With the Apify API (HTTP)

Run the Actor and get its results in one request. Replace `YOUR_API_TOKEN` with your token from **Settings → API & Integrations** in Apify Console.

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~weibo-comments-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"postUrls": ["https://weibo.com/2902408801/RluBSdMAw"], "maxResults": 50}'
```

Add `&format=csv` or `&format=xlsx` to the URL to get CSV or Excel instead of JSON. For long runs, start the run with `POST /v2/acts/hgservices~weibo-comments-scraper/runs`, and then read the items of the run's default dataset when it finishes.

#### With the JavaScript client

Install the client with `npm install apify-client`, then run:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('hgservices/weibo-comments-scraper').call({
    postUrls: ['https://weibo.com/2902408801/RluBSdMAw'],
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const comment of items) {
    console.log(comment.createdAt, comment.author?.name, comment.likesCount, comment.text);
}
```

#### With the Python client

Install the client with `pip install apify-client`, then run:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("hgservices/weibo-comments-scraper").call(
    run_input={
        "postUrls": ["https://weibo.com/2902408801/RluBSdMAw"],
        "maxResults": 50,
        "includeAllReplies": True,
    }
)

for comment in client.dataset(run.default_dataset_id).iterate_items():
    print(comment["createdAt"], comment["location"], comment["text"])
    for reply in comment["replies"]:
        print("    ↳", reply["text"])
```

#### With Claude, ChatGPT and other AI assistants (MCP)

Connect your AI assistant to the **Apify MCP server**. The assistant can then run this Actor for you and answer from the results. To give the assistant this Actor as a tool, use this server URL:

```
https://mcp.apify.com?tools=hgservices/weibo-comments-scraper
```

- **Claude (claude.ai or Claude Desktop):** open **Settings → Connectors**, click **Add custom connector** and paste the URL.
- **Claude Code:** run `claude mcp add --transport http apify "https://mcp.apify.com?tools=hgservices/weibo-comments-scraper"`.
- **Apify CLI:** run `apify mcp install claude-code --tools hgservices/weibo-comments-scraper` (also works for `cursor`, `vscode` and `codex`).
- **ChatGPT:** in **Settings → Apps & Connectors**, turn on developer mode, create a connector and paste the URL.
- **Cursor, VS Code and other MCP clients:** add the URL as a remote (HTTP) MCP server.

Sign in with your Apify account when asked. Then ask in plain language, for example:

- *"Get the top 100 comments of https://weibo.com/2902408801/RluBSdMAw and summarize the reactions in English."*
- *"Scrape the comments of these Weibo posts and tell me which provinces the commenters come from."*
- *"Get the comments of this Weibo post with full reply threads, and list the 10 comments with the most likes."*

#### With integrations

Send the results to **Google Sheets, Slack, email, Zapier, Make, n8n, Airbyte** or any **webhook** from the Actor's **Integrations** tab. For example, scrape the comments of a brand's newest posts every day and send them to a Google Sheet.

### Tips

- **Start small.** Run with a low **Max comments per post** to see the data, and then raise it.
- **Get replies only when you need them.** The first replies of each comment come with it. **Include full reply threads** makes more requests, so the run takes longer.
- **Paste any post URL.** Desktop URLs, mobile URLs and bare post IDs all work. Two URLs of the same post are scraped once.
- **Find the posts first.** Use **Weibo Post Scraper** or **Weibo Video Scraper** to find posts, and then give their URLs to this Actor.

### Limits

- **Weibo shows only part of a big comment section to visitors.** In tests, a post with 200,867 comments gave about 300 top-level comments, and a small post gave 37 of 90. Weibo folds the other comments. The `replyCount` field and the comment count of the post are Weibo's own numbers, so they can be higher than what you get.
- **Reply threads can also be partial.** With **Include full reply threads** on, you get the replies that Weibo shows under each comment. In tests, this was most of them.
- **The IP region is what Weibo shows.** It is the region of the commenter's IP address, not a verified home address.
- **Deleted, private and unknown posts are skipped.** The log tells you which posts were skipped.

### Related Actors

- **Weibo Post Scraper** gets the posts themselves: full text, stats and media.
- **Weibo Video Scraper** finds a user's video posts. Give their URLs to this Actor.
- **Weibo Profile Scraper** gets user profiles, followers and bios.
- **Weibo Hot Search Scraper** gets the 微博热搜 trending topics.

### FAQ, disclaimers and support

**Do I need a Weibo account or cookies?**
No. The Actor reads only the comments that Weibo shows to any visitor. It never logs in, so your account is never at risk.

**Do I need a proxy?**
No. The Actor uses Apify Proxy on its own and changes its IP address when Weibo limits a session.

**Why do I get fewer comments than the post shows?**
Weibo shows visitors only part of a big comment section. See **Limits** above.

**Why does a reply have `微博智搜AI生成` or a bot name as its `location`?**
Some replies come from Weibo's AI accounts, such as 微博智搜 (Weibo AI search). Weibo shows a label in the place of an IP region for these replies, and the Actor keeps that label. If Weibo shows no IP region, `location` is `null`.

**Can it scrape the comments of every post of a user, or of a keyword search?**
Not directly. This Actor takes post URLs. Use **Weibo Post Scraper** or **Weibo Video Scraper** to get the post URLs first.

**Is it legal to scrape Weibo comments?**
The Actor collects only data that is publicly available. Comments contain personal data, which is protected by laws such as the GDPR and China's PIPL. You are responsible for using the data in line with Weibo's terms of service and these laws. Scrape only what you have a legitimate reason to use.

**I found a problem or need a feature.**
Open an issue on the **Issues** tab, and we will look into it. Custom solutions for Weibo and other Chinese websites are available on request.

# Actor input Schema

## `postUrls` (type: `array`):

Post URLs such as https://weibo.com/2803301701/RlKmbFVUl or https://m.weibo.cn/detail/5351830879994049, or bare post IDs.

## `maxResults` (type: `integer`):

The most top-level comments to save for each post. Replies come with each comment and do not count. Set 0 for all that Weibo shows.

## `includeAllReplies` (type: `boolean`):

Add-on. Get the reply thread of each comment that has more replies than Weibo sends with it. You pay one add-on event for each comment whose thread adds new replies. When off, each comment has only the first replies that Weibo sends with it. This option does not change which comments you get or how many.

## Actor input object example

```json
{
  "postUrls": [
    "https://weibo.com/2803301701/RlKmbFVUl"
  ],
  "maxResults": 50,
  "includeAllReplies": 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 = {
    "postUrls": [
        "https://weibo.com/2803301701/RlKmbFVUl"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/weibo-comments-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 = {
    "postUrls": ["https://weibo.com/2803301701/RlKmbFVUl"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hgservices/weibo-comments-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 '{
  "postUrls": [
    "https://weibo.com/2803301701/RlKmbFVUl"
  ],
  "maxResults": 50
}' |
apify call hgservices/weibo-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/weibo-comments-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/vl96bMUQBu2vTyXFb/builds/AJNV8HugwrvmKjMKA/openapi.json