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

Extract Weibo hot search (微博热搜), posts, comments, replies, user profiles and keyword search results as JSON or CSV. No login, cookies or browser needed. A cheap Weibo API alternative for China trend monitoring, brand listening and KOL research. From $1 per 1,000 rows.

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

## Pricing

from $4.00 / 1,000 posts

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 — Hot Search, Posts, Comments & Profiles (No Login)

**Weibo scraper and Weibo API alternative for Chinese social media data.** Export the live **Weibo hot search list (微博热搜)**, **user profiles and their posts**, **any post by URL**, **comments and replies**, **keyword / hashtag search** and **trending posts** from Sina Weibo (新浪微博) — **no Weibo account, no cookies to paste, no browser**. Clean, flat JSON you can download as CSV/Excel or call from your code.

- ✅ **Hot search ranking**: ~50 topics + pinned topic with rank, heat, label (新/热/沸/爆), category and time on the list — optionally with the top posts of each topic
- ✅ **Profiles**: followers, following, post count, verification, bio, location, registration date, school/company, total likes/comments/reposts
- ✅ **User posts**: newest posts + **full history of photo/video posts** back to the first one
- ✅ **Posts by URL** with **comments** (hot or newest first) and **replies**
- ✅ **Keyword & #hashtag# search** (general, hot and real-time tabs combined)
- ✅ Full text of long posts (全文), pictures in full size, video MP4 links, hashtags, mentions, region (IP location), reposted post
- ✅ Date filters (`2026-10-01`, `7 days`, `24 hours`)
- ✅ **From $1 per 1,000 rows, no start fee** — **8× to 35× cheaper** than the most-used Weibo scraper ($35 per 1,000)

### What can you do with this Weibo scraper?

| Use case | How |
|---|---|
| **China trend monitoring** | Schedule the hot search every hour and get rank, heat and category of every trending topic; push it to Slack, Sheets or your BI tool. |
| **Brand & competitor monitoring in China** | Search your brand, products or #hashtags# and track what Weibo users say; download comments with likes and region. |
| **KOL / influencer research** | Export profiles (followers, verification, total interactions, labels) and their recent posts with likes, comments and reposts. |
| **Market research & sentiment analysis** | Feed post and comment text into sentiment, topic or LLM pipelines (RAG, summarisation, translation). |
| **Journalism, OSINT & academia** | Archive what accounts like 人民日报 publish, with timestamps (UTC + China time), media links and engagement. |
| **Social listening dashboards** | Combine hot search + keyword search + comments into one dataset with a `type` column. |

### Quick start (under 1 minute)

1. Click **Try for free**. The pre-filled input reads the live **hot search list** and searches the keyword `华为` (10 posts).
2. Add profiles, post URLs or more keywords when you need them, and cap the cost with *Max posts* and *Max comments* fields.
3. Click **Start**. The default run takes well under a minute. Download JSON, CSV or Excel, or call it through the Apify API.

### Input

Fill in any combination — everything runs in one go.

| Field | What it does |
|---|---|
| `includeHotSearch` | Scrape the live hot search ranking (微博热搜). |
| `hotSearchPostsPerTopic` | Also get the top N posts of every hot topic (0 = off). |
| `profiles` | User ids (`1669879400`), links (`https://weibo.com/u/1669879400`, `https://m.weibo.cn/u/...`, `https://weibo.com/rmrb`) or screen names (`@人民日报`). |
| `maxPostsPerProfile` | Newest posts per profile (default 20). `0` = only the profile row. |
| `includeProfileInfo` | One profile row per user (default on). |
| `postUrls` | Post links (`https://weibo.com/<uid>/<id>`, `https://m.weibo.cn/status/<id>`, `https://m.weibo.cn/detail/<mid>`) or ids. |
| `searchKeywords` | Words, brands or `#hashtags#` to search. |
| `searchSort` | `all` (general + hot + real-time + more, deduplicated), `general`, `hot` or `realtime`. |
| `maxPostsPerSearch` | Posts per keyword (default 30). |
| `maxTrendingPosts` | Posts from Weibo's public trending feed (热门微博). |
| `maxCommentsPerPost` | Comments per post from `postUrls` (default 20). |
| `commentsForAllPosts` | Also get comments for posts from profiles, search and hot search. |
| `commentSort` | `hot` (most liked first) or `time` (newest first). |
| `includeReplies` / `maxRepliesPerComment` | Also get replies to each comment. |
| `dateFrom` / `dateTo` | `2026-10-01` (China time), ISO date-time or relative (`7 days`, `24 hours`). |
| `fetchFullText` | Download the full text of truncated long posts (default on). |
| `proxyConfiguration` | Apify Proxy (default). If Weibo rate-limits you, use residential proxies, ideally CN or HK. |

If you leave everything empty, you get the hot search list.

#### Example: hourly hot search monitor with the top 3 posts of each topic

```json
{
  "includeHotSearch": true,
  "hotSearchPostsPerTopic": 3
}
```

#### Example: brand monitoring — search + comments

```json
{
  "searchKeywords": ["小米汽车", "#华为Mate80#"],
  "searchSort": "all",
  "maxPostsPerSearch": 80,
  "commentsForAllPosts": true,
  "maxCommentsPerPost": 50,
  "dateFrom": "7 days"
}
```

#### Example: KOL profiles with their last month of posts

```json
{
  "profiles": ["@人民日报", "https://weibo.com/u/1669879400"],
  "maxPostsPerProfile": 500,
  "dateFrom": "30 days"
}
```

#### Example: all comments and replies of one post

```json
{
  "postUrls": ["https://weibo.com/1669879400/RoDbmCVmy"],
  "maxCommentsPerPost": 5000,
  "commentSort": "hot",
  "includeReplies": true,
  "maxRepliesPerComment": 20
}
```

### Output

Every row has a `type`: `hot_search`, `profile`, `post`, `comment` or `error` (error rows are free). Use the **Posts**, **Comments**, **Hot search** and **Profiles** views in the dataset tab, or filter by `type` in your code. Real samples (shortened):

```json
{
  "type": "hot_search",
  "rank": 1,
  "word": "武汉警方通报网约车被围堵事件",
  "query": "#武汉警方通报网约车被围堵事件#",
  "heat": 2890091,
  "label": "新",
  "category": "民生新闻",
  "is_pinned": false,
  "is_ad": false,
  "on_list_since": "2026-11-02T14:13:22Z",
  "url": "https://s.weibo.com/weibo?q=%23...%23",
  "captured_at": "2026-11-02T14:29:41Z"
}
```

```json
{
  "type": "post",
  "id": "5358704929276970",
  "bid": "RoDbmCVmy",
  "url": "https://weibo.com/1669879400/RoDbmCVmy",
  "created_at": "2026-10-27T10:51:18Z",
  "created_at_china": "2026-10-27T18:51:18+08:00",
  "text": "选择困难所以都发一下🤣",
  "text_complete": true,
  "author_id": "1669879400",
  "author_name": "Dear-迪丽热巴",
  "user": {"id": "1669879400", "screen_name": "Dear-迪丽热巴", "verified": true, "avatar_url": "https://tvax1.sinaimg.cn/...", "...": "..."},
  "reposts_count": 1000000,
  "comments_count": 1000000,
  "likes_count": 5708775,
  "counts_capped": true,
  "region": "上海",
  "pics": ["https://wx1.sinaimg.cn/large/001P0DUIgy1iih3u5chkqj63b04eob2d02.jpg", "..."],
  "video": null,
  "links": [],
  "hashtags": [],
  "mentions": [],
  "is_pinned": false,
  "is_repost": false,
  "reposted_post": null,
  "input_type": "post",
  "input": "https://weibo.com/1669879400/RoDbmCVmy"
}
```

```json
{
  "type": "comment",
  "id": "5358705521721951",
  "post_id": "5358704929276970",
  "root_comment_id": "5358705521721951",
  "is_reply": false,
  "created_at_china": "2026-10-27T18:53:39+08:00",
  "text": "每一张都绝美[期待][期待] http://t.cn/AXjKCYtz",
  "likes_count": 40336,
  "replies_count": 4416,
  "region": "上海",
  "author_name": "护舒宝",
  "user": {"id": "1787569845", "verified": true, "verified_reason": "护舒宝官方微博", "followers_count": 620057, "...": "..."}
}
```

```json
{
  "type": "profile",
  "id": "1669879400",
  "screen_name": "Dear-迪丽热巴",
  "followers_count": 82583288,
  "following_count": 294,
  "posts_count": 1941,
  "verified": true,
  "verified_reason": "嘉行传媒签约演员",
  "location": "上海",
  "registered_at": "2010-07-02T13:19:58+08:00",
  "company": "嘉行传媒",
  "school": "上海戏剧学院",
  "total_interactions": 6255714721,
  "labels": ["V指数 文娱 87.28分", "近30天视频播放量324.7万", "..."]
}
```

**Post fields:** `id`, `bid`, `url`, `created_at` (UTC), `created_at_china`, `text`, `is_long_text`, `text_complete`, `author_id`, `author_name`, `user` (id, screen name, verified, verification reason, followers, avatar), `reposts_count`, `comments_count`, `likes_count`, `counts_capped`, `region`, `source` (client app), `pics` (full-size), `video` (MP4 URL, page URL, duration, cover, plays), `links`, `hashtags`, `mentions`, `is_pinned`, `edited`, `is_repost`, `reposted_post`, `input_type`, `input`, `keyword`, `search_tab`, `hot_rank`, `scraped_at`.

**Comment fields:** `id`, `post_id`, `post_url`, `root_comment_id`, `is_reply`, `reply_to`, `created_at`, `created_at_china`, `text`, `likes_count`, `replies_count`, `floor_number`, `region`, `liked_by_author`, `pics`, `author_id`, `author_name`, `user`.

### Pricing

Pay per event — you only pay for rows you get, **no start fee**:

| Event | Price | Per 1,000 |
|---|---|---|
| Post | $0.004 | **$4** |
| Comment or reply | $0.002 | **$2** |
| Profile | $0.004 | **$4** |
| Hot search topic | $0.001 | **$1** |
| Error rows | free | — |

Examples: 1,000 posts = **$4** · a post with 1,000 comments ≈ **$2** · a daily hot search snapshot for a month ≈ **$1.56**. The most-used Weibo scraper on Apify charges $35 per 1,000 items. Set **Max cost per run** in the run options to cap any run — the scraper stops cleanly at your limit.

### What works without login (and what does not)

This scraper only uses what Weibo shows to **logged-out visitors**, so you never risk an account. Measured on 2 Nov 2026:

| Data | Without login |
|---|---|
| Hot search ranking | ✅ full list (~50 topics + pinned) |
| Profile info | ✅ |
| Post by URL / id | ✅ |
| Comments | ✅ deep pagination (hundreds or thousands per post) |
| Replies to comments | ✅ |
| User posts | ✅ the **10 newest posts of any kind** + **every post with photos or video** back to the first one. Older text-only posts and reposts need login. |
| Keyword search | ⚠️ first page of each tab only: about **30-80 unique posts per keyword** with `searchSort: all`. Deeper search pages need login. |
| Repost lists, followers/following lists | ❌ need login — not offered |

### FAQ

**Do I need a Weibo account or cookies?** No. The scraper gets the same anonymous visitor cookies a browser receives when it opens weibo.com, and reads Weibo's public JSON endpoints (weibo.com/ajax and m.weibo.cn). No browser, so runs are fast and cheap (256 MB).

**Why is `reposts_count` exactly 1000000 with `counts_capped: true`?** Weibo displays "100万+" for very large counters and does not reveal the exact number to visitors. Treat it as "1,000,000 or more".

**Why do picture links fail in my browser?** Weibo's image CDN (sinaimg.cn) checks the referrer. Download them with the header `Referer: https://weibo.com/`. Video links contain an expiry time; download them soon after the run.

**Which dates and time zones?** `created_at` is UTC; `created_at_china` is Beijing time (UTC+8). Date filters without a time zone are read as China time.

**Can I get more than ~80 posts for a keyword?** Not without login. Run the same keywords on a schedule with `searchSort: realtime` and `dateFrom: "24 hours"` to build a growing archive — duplicates inside a run are never charged twice.

**Is it legal?** It only reads information that is publicly visible on Weibo without logging in and does not bypass captchas or paywalls. Weibo's terms restrict automated access; you are responsible for how you use the data (e.g. GDPR/PIPL when processing personal data).

**Is this an official Weibo API?** No. It is an independent tool and a no-code alternative to the Weibo API for public data.

### Limits

- Works only with what Weibo shows to **logged-out visitors**. Keyword search returns the first page of each tab (about 30-80 unique posts per keyword).
- User timelines return the 10 newest posts plus every post with photos or video; older text-only posts and reposts need a login and are not offered.
- Repost lists and follower/following lists need login and are not available.
- Picture links need the header `Referer: https://weibo.com/` and video links expire, so download media soon after the run.

### Use it from code (API)

Every Apify Actor is also an API. Replace `<YOUR_API_TOKEN>` with the token from your Apify account (Settings, API & Integrations).

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('phantom-x64/weibo-scraper').call({
    "includeHotSearch": true,
    "searchKeywords": [
      "华为"
    ],
    "maxPostsPerSearch": 20
  });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_API_TOKEN>')
run = client.actor('phantom-x64/weibo-scraper').call(run_input={
      "includeHotSearch": True,
      "searchKeywords": [
        "华为"
      ],
      "maxPostsPerSearch": 20
    })
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

You can also start it from Make, Zapier, n8n or Google Sheets with the Apify integrations, schedule it, or call it as a tool from an AI agent through the Apify MCP server.

### Support and feedback

Found a bug, need a new field or another source? Open an issue in the **Issues** tab of this Actor page. Reports with a run link are fixed fastest. If it saves you time, a short review on the Store page helps other people find it.

# Actor input Schema

## `includeHotSearch` (type: `boolean`):

Scrape the live Weibo hot search ranking (about 50 topics plus the pinned topic) with rank, heat, label (新/热/沸/爆) and category. If you give no profiles, posts or keywords, the hot search list is scraped anyway.

## `hotSearchPostsPerTopic` (type: `integer`):

Also return up to this many top posts for every hot search topic (0 = only the ranking). Each topic adds one or two requests.

## `profiles` (type: `array`):

Weibo users to scrape: numeric user id (1669879400), profile links (https://weibo.com/u/1669879400, https://m.weibo.cn/u/1669879400, https://weibo.com/rmrb) or a screen name (@人民日报). Returns one profile row and the newest posts of each user.

## `maxPostsPerProfile` (type: `integer`):

Newest posts to save per profile (0 = only the profile row). Without login Weibo shows the 10 newest posts of any kind plus the full history of posts that contain photos or videos.

## `includeProfileInfo` (type: `boolean`):

Add one row per profile: followers, following, post count, verification, bio, location, IP location, registration date, total likes/comments/reposts and more.

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

Single Weibo posts to scrape, with their comments. Accepts https://weibo.com/<uid>/<id>, https://m.weibo.cn/status/<id>, https://m.weibo.cn/detail/<mid> or a bare id.

## `searchKeywords` (type: `array`):

Find posts that mention these words, brands or #hashtags#. Without login Weibo shows the first page of each search tab, so expect up to about 80 unique posts per keyword with "All tabs".

## `searchSort` (type: `string`):

Which Weibo search tabs to read for each keyword. "All tabs" combines general, hot, real-time and more results (deduplicated) for the widest coverage.

## `maxPostsPerSearch` (type: `integer`):

Maximum posts saved per search keyword.

## `maxTrendingPosts` (type: `integer`):

Also scrape up to this many posts from Weibo's public trending feed (0 = off).

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

Top-level comments to save for each post from "Post URLs" (and for every other post if "Comments for all posts" is on). 0 = no comments.

## `commentsForAllPosts` (type: `boolean`):

Also download comments for posts found through profiles, search, hot search and trending (not only for "Post URLs"). Can multiply the number of rows and the cost.

## `commentSort` (type: `string`):

"Hot" returns the most-liked comments first (like the Weibo app); "Time" returns the newest first.

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

Also download replies (sub-comments) of each comment. Replies are comment rows with is_reply = true and the root comment id.

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

Maximum replies saved for each comment when replies are on.

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

Only posts published on or after this date (profiles, search, trending). Accepts YYYY-MM-DD (China time), an ISO date-time, or a relative value such as "7 days" or "24 hours". Profile scraping stops once it reaches older posts.

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

Only posts published on or before this date (a plain YYYY-MM-DD includes the whole day, China time). Same formats as the oldest date.

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

Weibo truncates long posts ("全文"). When on, the full text is downloaded with one extra request per long post.

## `maxConcurrency` (type: `integer`):

How many profiles, posts or keywords are processed at the same time. Each one is read at a polite pace with its own session.

## `requestDelayMs` (type: `integer`):

Minimum pause between two requests of the same session, in milliseconds (a small random jitter is added).

## `maxRetries` (type: `integer`):

How many times a failed request (network error, rate limit, HTTP 5xx or expired visitor cookie) is retried with a new session and exponential backoff.

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

Apify Proxy is recommended. If Weibo starts rate-limiting, switch to residential proxies (country CN or HK works best).

## Actor input object example

```json
{
  "includeHotSearch": true,
  "hotSearchPostsPerTopic": 0,
  "maxPostsPerProfile": 20,
  "includeProfileInfo": true,
  "searchKeywords": [
    "华为"
  ],
  "searchSort": "all",
  "maxPostsPerSearch": 10,
  "maxTrendingPosts": 0,
  "maxCommentsPerPost": 20,
  "commentsForAllPosts": false,
  "commentSort": "hot",
  "includeReplies": false,
  "maxRepliesPerComment": 10,
  "fetchFullText": true,
  "maxConcurrency": 3,
  "requestDelayMs": 1000,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "includeHotSearch": true,
    "searchKeywords": [
        "华为"
    ],
    "maxPostsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("phantom-x64/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 = {
    "includeHotSearch": True,
    "searchKeywords": ["华为"],
    "maxPostsPerSearch": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("phantom-x64/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 '{
  "includeHotSearch": true,
  "searchKeywords": [
    "华为"
  ],
  "maxPostsPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call phantom-x64/weibo-scraper --silent --output-dataset

```

## MCP server setup

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