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

Weibo scraper for 微博 posts by keyword, user timelines, post comments and replies, user profiles and the hot search board. No login or cookies. Date filters, only-new monitoring, clean English fields, JSON/CSV/Excel.

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

## Pricing

from $3.79 / 1,000 result rows

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

## Weibo Scraper - Posts, Comments, Hot Search & Profiles

**Weibo Scraper** extracts public data from Sina Weibo (微博): posts by keyword, any user's timeline, single posts with their comments and replies, user profiles, and the live hot search board (微博热搜). No Weibo account, no cookies, no proxies to set up. Every row has the same clean English field names, ISO timestamps and numeric counts, ready for spreadsheets, BI tools and AI pipelines.

![Weibo Scraper output in Apify: post time, text, likes, comments, reposts, author followers and post link (author names blurred)](https://api.apify.com/v2/key-value-stores/lwQu1lCMCLQIIhSMQ/records/weibo-scraper-output.png)

*Real output from a default run of Weibo Scraper in Apify Console.*

### What can Weibo Scraper do?

- 🔎 **Search Weibo posts by keyword**: top, latest or hot results, with optional date range, verified/media-only authors, original-only, and image or video filters.
- 👤 **Scrape a user's posts**: paste numeric UIDs or profile URLs (`weibo.com/u/…`, `m.weibo.cn/u/…`, `weibo.com/customname`). No cookie needed.
- 💬 **Scrape comments and replies**: for any post you found or pasted, with per-post and per-comment limits.
- 📇 **Get user profiles**: followers, following, post count, verification type and reason, bio, location, lifetime likes.
- 🔥 **Track the hot search board**: the realtime 热搜榜 (about 50 topics with heat values and badges) or the society, entertainment, technology, life, sports and games boards.
- 🔁 **Monitor for new posts**: turn on *Only new posts*, schedule the actor, and each run returns only posts earlier runs did not deliver, per keyword or per user.
- 🧾 **Long posts in full**: optionally fetch the complete text of 长微博 that Weibo cuts in lists.

### What data do you get?

Every row has a `dataType` (`post`, `comment`, `user` or `trend`) and shares common fields (`id`, `url`, `text`, `createdAt`, `scrapedAt`).

| Field | Rows | Description |
|---|---|---|
| `id`, `shortId`, `url` | post | Numeric post ID (mid), short ID (mblogid) and full `https://weibo.com/<uid>/<shortId>` link |
| `text`, `isLongText`, `textTruncated` | post, comment | Original Chinese text; whether Weibo cut it |
| `createdAt` | post, comment | Publish time, ISO 8601 (UTC) |
| `authorId`, `authorName`, `authorUrl`, `authorAvatarUrl` | post, comment | Author identity |
| `authorVerified`, `authorVerifiedType`, `authorVerifiedReason`, `authorFollowers` | post, comment | Verification badge (personal / organization / creator) and follower count |
| `likes`, `comments`, `reposts` | post | Engagement counts as numbers |
| `images`, `videoUrl`, `videoCoverUrl`, `videoDurationSec`, `videoPlays` | post | Full-size image URLs and the best MP4 |
| `hashtags`, `mentions` | post, comment | `#话题#` topics and `@` mentions |
| `location`, `source` | post, comment | IP region shown by Weibo (e.g. 广东) and the client/byline |
| `isRepost`, `repostOfId`, `repostOfUrl`, `repostOfText`, `repostOfAuthorName` | post | The original post behind a repost |
| `isAd`, `isPinned`, `searchKeyword`, `sourceType` | post | Promoted / pinned flags and where the row came from |
| `postId`, `isReply`, `parentCommentId`, `replyToCommentId`, `replyToUserName`, `replyCount`, `isByPostAuthor`, `floor` | comment | Thread structure |
| `name`, `followers`, `following`, `postsCount`, `verifiedType`, `verifiedReason`, `description`, `gender`, `totalLikes`, `totalInteractions` | user | Profile and lifetime stats |
| `rank`, `heat`, `label`, `hashtag`, `board`, `isPinned` | trend | Hot search position, heat value and badge (热 / 新 / 沸 / 爆) |

### How much does it cost to scrape Weibo?

You pay per result row: **$4.99 per 1,000 rows** (posts, comments, users or trends), plus a small start fee of $0.003 per run. On paid Apify plans the per-row price drops automatically (Bronze and above get volume discounts); the Pricing tab shows your exact rate.

A few options look each post or profile up individually, and add a **detail lookup of $0.004 per row**: post details mode, user profiles mode, full text of long posts, and the full-data fill-in for date-filtered or latest searches. Nothing else is charged; errors are never billed.

- **Daily hot search snapshot**: about 50 topics = $0.25 + $0.003 per run, about $7.60 a month at one run a day.
- **Brand monitoring**: 500 posts for 咖啡 with their top 20 comments each (about 10,500 rows) = about $52. The same 500 posts without comments = $2.50.
- **10 competitor profiles**: 10 × ($0.00499 + $0.004) = $0.09.

Your run's *maximum charge* setting is always respected: the actor stops before it would exceed it and keeps what it collected.

On the Apify free plan, each run returns a preview of up to 20 results; any paid Apify plan unlocks full results.

### How to use Weibo Scraper

1. Click **Try for free** and open the **Input** tab.
2. Pick **What to scrape**: keyword search, user posts, post details, user profiles or hot search.
3. Fill the matching field: keywords, user IDs/URLs or post URLs. Hot search needs nothing else.
4. Set **Max posts per keyword / user** and, if you want, turn on comments, replies or date filters.
5. Click **Start**. Download the results as JSON, CSV, Excel or HTML, or read them over the API.

Tip: Weibo is indexed in Chinese. Search for 星巴克 rather than Starbucks to get many more posts.

### Input example

```json
{
    "mode": "search",
    "keywords": ["新能源汽车", "#电动车#"],
    "sort": "latest",
    "dateFrom": "2026-10-01",
    "dateTo": "2026-10-15",
    "maxResults": 200,
    "includeComments": true,
    "maxCommentsPerPost": 20
}
```

### Output example

```json
{
    "dataType": "post",
    "id": "5358987798121682",
    "shortId": "RoKxBy4OS",
    "url": "https://weibo.com/1000000001/RoKxBy4OS",
    "text": "周末去了新开的咖啡店，环境很好 #城市咖啡地图#",
    "isLongText": false,
    "textTruncated": false,
    "createdAt": "2026-10-28T05:35:19.000Z",
    "authorId": "1000000001",
    "authorName": "示例用户",
    "authorUrl": "https://weibo.com/u/1000000001",
    "authorVerified": true,
    "authorVerifiedType": "personal",
    "authorVerifiedReason": "美食博主",
    "authorFollowers": 42650,
    "authorAvatarUrl": "https://tvax1.sinaimg.cn/crop.0.0.180.180.1024/example.jpg",
    "reposts": 32,
    "comments": 18,
    "likes": 157,
    "images": ["https://wx2.sinaimg.cn/large/example1.jpg"],
    "videoUrl": null,
    "hashtags": ["城市咖啡地图"],
    "mentions": [],
    "location": "广东",
    "isRepost": false,
    "isAd": false,
    "isPinned": false,
    "searchKeyword": "咖啡",
    "sourceType": "search",
    "scrapedAt": "2026-10-28T20:07:56.753Z"
}
```

A hot search row looks like `{"dataType": "trend", "rank": 1, "text": "…", "heat": 134414, "label": "热", "board": "realtime", "url": "https://s.weibo.com/weibo?q=%23…%23"}`.

### Use with the API

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/groupoject~weibo-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "hotSearch"}'
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("groupoject/weibo-scraper").call(run_input={
    "mode": "userPosts",
    "userIds": ["https://weibo.com/u/1682207150"],
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["createdAt"], item["likes"], item["text"][:60])
```

**JavaScript**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('groupoject/weibo-scraper').call({
    mode: 'posts',
    postUrls: ['https://weibo.com/6860967627/RoNs9kE4B'],
    includeComments: true,
    includeReplies: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => i.dataType === 'comment').length, 'comments');
```

### Use with AI agents (MCP)

Add the actor to Claude, Cursor or any MCP client through the Apify MCP server:
`https://mcp.apify.com?tools=groupoject/weibo-scraper`

Example prompt: *"Use the Weibo scraper to get today's top 20 hot search topics and summarize them in English."*

### Integrations

Send results to **Google Sheets**, **Make**, **Zapier**, **n8n**, Slack or any **webhook** with Apify integrations. For alerts, schedule the actor (for example every hour) with *Only new posts* on, and connect a webhook or Slack integration to the run's dataset.

### FAQ

#### Is it legal to scrape Weibo?

The actor reads only public data that anyone can see on Weibo without logging in. You are responsible for how you use it: respect Weibo's terms, copyright in post content, and data protection laws (PIPL, GDPR) when you store personal data such as names and avatars.

#### Do I need a Weibo account, cookies or proxies?

No. Everything, including user timelines and comments, works without your login or cookies, and you don't configure proxies.

#### How many posts can I get per keyword?

Weibo's own search stops at about 50 pages per query (roughly 500 posts for top/hot results, fewer for date-filtered searches). Split long periods into several date windows, or add related keywords, to go further.

#### Why does a post have empty like or comment counts?

Date-filtered and latest searches use Weibo's web search, which doesn't show counts. Keep *Full data for date-filtered searches* on (default) and each post is looked up to fill them in.

#### Why is the text cut off?

Weibo shortens long posts (长微博) in lists; those rows have `textTruncated: true`. Turn on *Full text of long posts*, or use post details mode, to get the whole text.

#### Why did I get fewer results than I asked for?

Weibo had no more matching posts, the date window was narrow, *Only new posts* skipped posts delivered before, or your run's maximum charge was reached. The run's `SUMMARY` record says why it stopped, and `ERRORS` lists inputs that failed (never billed).

#### Why did I only get 20 results?

You are on the Apify free plan, where each run returns a preview of up to 20 results. Upgrade to any paid Apify plan to get full results; the run's status message and `SUMMARY` (`freePlanPreview: true`) show when the preview limit applied.

#### How do I monitor a keyword or account?

Turn on *Only new posts*, give the monitor its own *State key*, set sort to *Latest*, and create a schedule in Apify. The first run saves the current posts as a baseline; later runs return only newer posts.

#### How fast is it?

A 20-post search finishes in under 10 seconds; 100 posts take about 30 seconds. Comments add about one request per 20 comments.

### Related actors

- [Reddit Scraper](https://apify.com/groupoject/reddit-scraper): posts and comments from Reddit.
- [X Profile & Post Monitor](https://apify.com/groupoject/x-profile-post-monitor): new posts and profile changes on X/Twitter.
- [YouTube Comments Scraper](https://apify.com/groupoject/youtube-comments-scraper-api): comments and replies from YouTube videos.
- [TrendPulse Keyword Monitor](https://apify.com/groupoject/trendpulse-keyword-monitor): track keyword trends over time.
- [Google News Scraper](https://apify.com/groupoject/google-news-scraper): news coverage for the same topics.

# Actor input Schema

## `mode` (type: `string`):

Pick one: posts by keyword search, posts from user timelines, single posts by URL (with comments and replies), user profiles, or the Weibo hot search board (微博热搜).

## `keywords` (type: `array`):

Keyword search mode. One search per keyword. Chinese keywords return far more posts than English ones (e.g. 咖啡 rather than coffee). Hashtags work too: #话题#.

## `sort` (type: `string`):

Top = Weibo's default relevance ranking (综合). Latest = newest first (实时), best for monitoring. Hot = most popular (热门).

## `contentFilter` (type: `string`):

Only posts with images, or only posts with video.

## `dateFrom` (type: `string`):

Optional. YYYY-MM-DD (Beijing time) or an ISO date-time. Works in keyword search (uses Weibo advanced search) and user posts.

## `dateTo` (type: `string`):

Optional. YYYY-MM-DD (Beijing time, whole day included) or an ISO date-time.

## `authorFilter` (type: `string`):

Keyword search only: limit to verified accounts or media accounts. Uses Weibo advanced search.

## `originalOnly` (type: `boolean`):

Skip reposts. In keyword search this uses Weibo advanced search; in user posts it reads the user's original posts only.

## `enrichSearchResults` (type: `boolean`):

Weibo's advanced search (used when you set dates, an author type or original-only) returns posts without like/comment/repost counts or follower numbers. On: each post is looked up once to fill them in (billed as a detail lookup). Off: cheaper, counts stay empty.

## `excludeAds` (type: `boolean`):

Drop promoted posts (广告) from search results and paid entries from the hot search board.

## `userIds` (type: `array`):

User posts and user profiles modes. Numeric UID (1682207150), profile URL (https://weibo.com/u/1682207150, https://m.weibo.cn/u/1682207150) or custom profile URL (https://weibo.com/nfrb).

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

Post details mode. Post URL (https://weibo.com/6860967627/RoNs9kE4B, https://m.weibo.cn/detail/5359099734920605), numeric post ID or short ID (RoNs9kE4B).

## `hotSearchBoard` (type: `string`):

Which trending list to read in hot search mode. Realtime is the main 微博热搜 board (about 50 topics with heat values).

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

Cap on posts per keyword (search), per user (user posts), in total (post details), or topics (hot search). Comments are capped separately below. Your run's maximum charge also caps the output.

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

Also save the comments of every post found (keyword search, user posts or post details). Each comment is one row.

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

Top-level comments per post, in Weibo's hot order.

## `includeReplies` (type: `boolean`):

Also save replies (楼中楼) under each comment. Needs 'Include comments'.

## `maxRepliesPerComment` (type: `integer`):

Replies saved under each comment.

## `fetchFullText` (type: `boolean`):

Weibo cuts long posts (长微博) in lists. On: each cut post is looked up once to get the whole text (billed as a detail lookup). Off: those rows have textTruncated = true.

## `onlyNew` (type: `boolean`):

Keyword search and user posts: return only posts that earlier runs with the same state key did not deliver. Schedule the actor for an alert-style feed. The first run returns the current posts as the baseline.

## `stateKey` (type: `string`):

Name of the memory used by 'Only new posts'. Use a different key for each separate monitor.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "人工智能"
  ],
  "sort": "top",
  "contentFilter": "all",
  "authorFilter": "all",
  "originalOnly": false,
  "enrichSearchResults": true,
  "excludeAds": true,
  "hotSearchBoard": "realtime",
  "maxResults": 20,
  "includeComments": false,
  "maxCommentsPerPost": 20,
  "includeReplies": false,
  "maxRepliesPerComment": 10,
  "fetchFullText": false,
  "onlyNew": false,
  "stateKey": "default"
}
```

# Actor output Schema

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

Posts, comments, users or trending topics (one row each, see dataType).

## `summary` (type: `string`):

Rows saved per type, API calls and stop reason.

## `errors` (type: `string`):

Inputs that could not be scraped and why (never billed).

# 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 = {
    "mode": "search",
    "keywords": [
        "人工智能"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("groupoject/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 = {
    "mode": "search",
    "keywords": ["人工智能"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("groupoject/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 '{
  "mode": "search",
  "keywords": [
    "人工智能"
  ],
  "maxResults": 20
}' |
apify call groupoject/weibo-scraper --silent --output-dataset

```

## MCP server setup

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