# Weibo Scraper | Posts, Profiles and Engagement (`silentflow/weibo-scraper`) Actor

Weibo scraper for public profiles: get every post with exact publish time, reposts, comments, likes, pictures, videos and the original of each repost, plus author followers and verification on every row. No login or cookie needed. Filter by date to monitor KOLs, brands and state media daily.

- **URL**: https://apify.com/silentflow/weibo-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (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 $17.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.
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

**Turn any public Weibo profile into a table: every post with its exact publish time, reposts, comments and likes, its pictures and videos, and the author's followers on each row.** 50 posts with full text in 13 seconds, no Weibo account needed.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/YXm81xySHg6uRkewS/records/weibo-scraper-how-it-works-v1.png)

1. **You paste one or more profiles.** A profile address, a numeric user id or a nickname all work, in the same field. Post addresses go in a second field when you want single posts.
2. **The timeline is read newest first.** Long posts are read in full, reposts come with the post they quote, and a date floor stops the run at the first post older than the day you pick.
3. **One row comes back per post.** 33 fields: the post with its exact numbers and media, the original it reposts, and the author with followers, verification and bio. Ready for a spreadsheet, a database or an AI pipeline.

### ✨ Why teams choose this over other Weibo scrapers

Hitting a login wall after two pages of a Weibo profile? Pasting your logged-in browser session into a scraper and hoping it still works tomorrow? Getting "2733.1万" followers and "9月19日 22:21" back as text, then cleaning them by hand?

- 🔓 **Public profiles without an account.** No login, no browser session to paste, no phone number. Paste a profile and press Start. The most used Weibo scraper on the Store asks for your logged-in session before it reads a timeline.
- 📅 **Dates you can sort and filter.** Every row carries the exact publish time in RFC 3339 UTC (`2026-09-19T04:30:20Z`), not "昨天 12:30" in Beijing time. Filter a week, chart a cadence, join on a calendar, no cleaning needed.
- 🔢 **Numbers as numbers.** Reposts, comments and likes are integers on every row, the exact values Weibo shows for the post. `27331000` followers, not "2733.1万".
- 📄 **Long posts in full.** Weibo cuts a long post after about 140 characters with "展开全文". This scraper reads it again in full by default, and brings back the region it was posted from with it.
- 🔁 **Reposts with what they quote.** A repost is a row with `isRepost: true` and `repostOf`: the original's author, text, pictures, counts and time. Measure the spread of a post, or turn reposts off with one switch.
- 👤 **The post and its author in the same row.** 22 post fields and 11 author fields together: name, verification, bio, gender, followers, following, total posts, avatar. One dataset answers both "how did this post do" and "how big is this account".
- ⏱️ **Built for daily monitoring.** Set `publishedAfter` to `1 day` on a schedule and each run returns only the new posts. The timeline is newest first, so the run stops at the first older post and watching 100 accounts stays quick.
- 🧹 **A clean dataset, every time.** One row is one real post. An unknown profile or a deleted post produces no row and a clear message on the run. Unknown values are `null`, never an empty string, and no post appears twice.

### 🎯 What you can do with Weibo data

| Team | What they build |
|------|-----------------|
| China market research | A weekly digest of what 50 KOLs published, with likes per post and the topics they used |
| Brand and PR | A spread report of a campaign post: every account that reposted it, with their followers and the text they added |
| Investor relations and equity research | A daily feed of every post by listed-company executives and official accounts, pushed to a database |
| Newsrooms | A monitor of state and regional media accounts (人民日报, 央视新闻), with full text and pictures, minutes after publication |
| Influencer marketing | A vetting sheet per creator before a deal: engagement of the last 50 posts, share of reposts, posting cadence, verification |
| Social listening | A watchlist of 200 accounts read every morning with `publishedAfter: 1 day`, new posts only |
| Data and AI | A corpus of Chinese social text with topics, mentions, dates and engagement, for classification, sentiment or fine-tuning |

### 📥 Input parameters

#### Essentials

| Field | Type | Description |
|-------|------|-------------|
| `profiles` | array | Profiles to read, one per line. Accepts a profile address (`https://weibo.com/u/1749127163`, `https://weibo.com/leijun`, `https://m.weibo.cn/u/1749127163`), a numeric user id (`1749127163`) or a nickname (`雷军`). |
| `postUrls` | array | Single posts to read, one per line: a post address (`https://weibo.com/1749127163/RiOrRC766`, `https://m.weibo.cn/detail/5344838319083750`) or a post id. Each becomes one row. |
| `maxItems` | integer, default `50` | Maximum rows per profile. Posts read by address do not count. |

#### 🔍 Filters

| Field | Type | Description |
|-------|------|-------------|
| `publishedAfter` | string | Keep only posts published after a date (`2026-01-31`) or within an age (`7 days`, `2 weeks`, `3 months`, `1 year`). The run stops at the first older post. |
| `includeReposts` | boolean, default `true` | On: reposts are rows too, with the original in `repostOf`. Off: only the profile's own posts. |

#### 📄 Output

| Field | Type | Description |
|-------|------|-------------|
| `includeFullText` | boolean, default `true` | On: a post the timeline cuts short is read again in full, with its region. Off: a faster listing that keeps the preview text of long posts. |

#### ⚙️ Advanced

| Field | Type | Description |
|-------|------|-------------|
| `debugMode` | boolean, default `false` | Adds detailed lines to the run log. Leave it off for normal runs. |

### 📊 Output data

Each row is one post. A pinned video post of a personal account looks like this:

```json
{
  "id": "5343890815061589",
  "bid": "RipNDleKx",
  "url": "https://weibo.com/1749127163/RipNDleKx",
  "text": "小米澎程，四天四城，首批车主交付仪式圆满完成。\n\n从徐州、上海、杭州、到成都，我们见到了特别多喜欢和认可澎程的车主，也见证了特别多幸福、喜悦的时刻。感谢每一位车主的信任和支持。 小米澎程的微博视频",
  "isLongText": false,
  "isRepost": false,
  "isPinned": true,
  "topics": [],
  "mentions": [],
  "source": "微博视频号",
  "userId": "1749127163",
  "userName": "雷军",
  "userUrl": "https://weibo.com/u/1749127163",
  "userDescription": null,
  "isVerified": true,
  "verifiedReason": "小米创办人，董事长兼CEO；金山软件董事长；天使投资人。",
  "userGender": "male",
  "followersCount": 27331000,
  "followingCount": 1642,
  "postsCount": 21943,
  "userAvatarUrl": "https://tvax4.sinaimg.cn/crop.0.0.1080.1080.180/001Un9Srly8iguza3zz5rj60u00u0gp602.jpg",
  "repostsCount": 55,
  "commentsCount": 330,
  "likesCount": 2311,
  "location": null,
  "createdAt": "2026-09-16T13:45:18Z",
  "images": [],
  "videoUrl": "https://f.video.weibocdn.com/o0/iZPO2nRplx08AQwCoB1u01041200EKGm0E010.mp4?label=mp4_720p",
  "videoCoverUrl": "https://wx1.sinaimg.cn/orj480/f2c9838cly1ih5o026fypj20mi0u0adc.jpg",
  "videoDuration": 61.253,
  "repostOf": null,
  "input": "https://weibo.com/u/1749127163",
  "scrapedAt": "2026-09-20T04:20:58Z"
}
```

A repost keeps the same 33 columns and carries the post it quotes in `repostOf` (author block shortened here):

```json
{
  "id": "5344838319083750",
  "bid": "RiOrRC766",
  "url": "https://weibo.com/1749127163/RiOrRC766",
  "text": "好看！//@柿子然然:这个颜色最吸睛哦！",
  "isLongText": false,
  "isRepost": true,
  "isPinned": false,
  "topics": [],
  "mentions": ["柿子然然"],
  "source": "Xiaomi 18 Fold",
  "userId": "1749127163",
  "userName": "雷军",
  "repostsCount": 70,
  "commentsCount": 231,
  "likesCount": 1013,
  "location": null,
  "createdAt": "2026-09-19T04:30:20Z",
  "images": [],
  "videoUrl": null,
  "repostOf": {
    "id": "5344060610449545",
    "bid": "Riudv1SWJ",
    "url": "https://weibo.com/4073292684/Riudv1SWJ",
    "userId": "4073292684",
    "userName": "小米澎程",
    "text": "早上好，分享一组蝴蝶谷蓝，户外实拍图。\n在阳光照射下，呈现出宝石般的细腻光泽，\n大家看看质感怎么样？\n\n拍摄：@普通人人GreyWolfe",
    "images": [
      "https://wx3.sinaimg.cn/large/f2c9838cly1ih5ttd7yqpj277a4svb2j.jpg",
      "https://wx1.sinaimg.cn/large/f2c9838cly1ih5ttiwly3j270h4obx73.jpg"
    ],
    "videoUrl": null,
    "repostsCount": 81,
    "commentsCount": 23,
    "likesCount": 140,
    "createdAt": "2026-09-17T01:00:00Z"
  },
  "input": "https://weibo.com/u/1749127163",
  "scrapedAt": "2026-09-20T04:22:46Z"
}
```

### 🗂️ Data fields

33 fields per row: 3 identity, 7 content, 11 author, 3 measures, 2 place and time, 4 media, 1 repost, 2 meta. `repostOf` is the only nested field, with 12 fields of its own.

| Group | Fields |
|-------|--------|
| Identity | `id` (the numeric post id, or mid), `bid` (the short id in the address), `url` |
| Content | `text` (plain text, line breaks kept), `isLongText`, `isRepost`, `isPinned`, `topics` (the `#话题#` tags), `mentions` (the `@names`), `source` (the app or device the post was sent from) |
| Author | `userId`, `userName`, `userUrl`, `userDescription`, `isVerified`, `verifiedReason`, `userGender`, `followersCount`, `followingCount`, `postsCount`, `userAvatarUrl` |
| Measures | `repostsCount`, `commentsCount`, `likesCount` |
| Place and time | `location` (the region Weibo shows, `北京`), `createdAt` (RFC 3339, UTC) |
| Media | `images` (large size), `videoUrl`, `videoCoverUrl`, `videoDuration` (seconds) |
| Repost | `repostOf`: `id`, `bid`, `url`, `userId`, `userName`, `text`, `images`, `videoUrl`, `repostsCount`, `commentsCount`, `likesCount`, `createdAt` |
| Meta | `input` (the profile or post as you typed it), `scrapedAt` (RFC 3339, UTC) |

Good to know when you store the data:

- `id` is Weibo's permanent post id and `userId` the permanent user id. `url` (`https://weibo.com/{userId}/{bid}`) and `userUrl` are built from them and are permanent. A nickname or a custom address can change; the ids do not.
- `createdAt` is the publish time converted to UTC. Weibo shows Beijing time (UTC+8); add 8 hours to read it as a Chinese reader does.
- `location` is the region Weibo attaches to a post (`北京`, `广东`, or a country for posts sent from abroad). It is read with the full text of long posts, and always for posts read by address. Rows read from the timeline only carry `null`.
- `images` are the large versions of the pictures, on Weibo's image servers. They stay valid as long as the post keeps them. `videoUrl` is a signed link that expires within hours: download it in the same pipeline, or keep `videoCoverUrl` and `url` for later.
- `followersCount` is rounded by Weibo itself (`27331000` for "2733.1万", `158000000` for "1.58亿"). Post counts are exact.
- `verifiedReason` is the line Weibo shows under a verified name. `userDescription` is the bio, which many verified accounts leave empty.
- `isPinned` marks the post a profile keeps at the top of its timeline; it can be older than the posts below it.
- `topics` and `mentions` are read from the text and never contain the `#` or `@` sign.

### 🚀 Examples

#### Get the 50 latest posts of a profile

```json
{
  "profiles": ["https://weibo.com/u/1749127163"]
}
```

#### Pull only what a watchlist published since yesterday

Put this on a daily schedule. Each run returns the new posts and nothing else.

```json
{
  "profiles": ["人民日报", "央视新闻", "https://weibo.com/leijun"],
  "publishedAfter": "1 day",
  "maxItems": 100
}
```

#### Read three posts by address, with their originals and regions

```json
{
  "postUrls": [
    "https://weibo.com/1749127163/RiOrRC766",
    "https://m.weibo.cn/detail/5345185691339516",
    "5344838319083750"
  ]
}
```

#### Export an account's own posts of the last quarter, reposts left out

```json
{
  "profiles": ["https://weibo.com/rmrb"],
  "publishedAfter": "3 months",
  "includeReposts": false,
  "maxItems": 500
}
```

#### List a media account as fast as possible, preview text only

```json
{
  "profiles": ["2803301701"],
  "includeFullText": false,
  "maxItems": 200
}
```

#### Compare the engagement of two executives

```json
{
  "profiles": ["雷军", "https://weibo.com/u/1195242865"],
  "maxItems": 100,
  "includeReposts": false
}
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT or Cursor to give it full context about this scraper:

```
You have access to the Weibo Scraper on Apify: silentflow/weibo-scraper

Input schema:
- profiles (array of strings): profile addresses (weibo.com/u/{id}, weibo.com/{alias}, m.weibo.cn/u/{id}), numeric user ids or nicknames
- postUrls (array of strings, optional): post addresses (weibo.com/{userId}/{bid}, m.weibo.cn/detail/{id}) or post ids
- maxItems (integer, default 50): max rows per profile
- publishedAfter (string, optional): "2026-01-31" or an age like "7 days", "2 weeks", "3 months", "1 year"; the run stops at the first older post
- includeReposts (boolean, default true): reposts as rows with the original in repostOf
- includeFullText (boolean, default true): long posts read in full, with their region
- debugMode (boolean, default false)

Output, one row per post (33 fields, null when unknown):
- id (string), bid (string), url (string, permanent)
- text (string), isLongText, isRepost, isPinned (booleans), topics (string[]), mentions (string[]), source (string)
- userId, userName, userUrl, userDescription, verifiedReason, userGender, userAvatarUrl (strings), isVerified (boolean)
- followersCount, followingCount, postsCount (integers)
- repostsCount, commentsCount, likesCount (integers)
- location (string), createdAt (RFC 3339 UTC)
- images (string[]), videoUrl (string, expires within hours), videoCoverUrl (string), videoDuration (number, seconds)
- repostOf ({id, bid, url, userId, userName, text, images, videoUrl, repostsCount, commentsCount, likesCount, createdAt} or null)
- input (string), scrapedAt (RFC 3339 UTC)

No account, no login and no API key needed. Use apify-client for Python or JavaScript.
```

### 💻 Integrations

#### Vet a creator before a campaign (Python)

```python
from statistics import median
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("silentflow/weibo-scraper").call(run_input={
    "profiles": ["https://weibo.com/leijun"],
    "maxItems": 50,
})
posts = list(client.dataset(run["defaultDatasetId"]).iterate_items())

own = [p for p in posts if not p["isRepost"]]
author = posts[0]
print(author["userName"], author["followersCount"], "followers, verified:", author["isVerified"])
print("Own posts:", len(own), "of", len(posts))
print("Median likes per own post:", median(p["likesCount"] for p in own))
print("Comments per 1,000 followers:", round(1000 * sum(p["commentsCount"] for p in own) / author["followersCount"], 2))
```

#### Post new items from a watchlist to Slack (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('silentflow/weibo-scraper').call({
    profiles: ['人民日报', '央视新闻', 'https://weibo.com/leijun'],
    publishedAfter: '1 day',
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const post of items) {
    await fetch(process.env.SLACK_WEBHOOK_URL, {
        method: 'POST',
        body: JSON.stringify({ text: `${post.userName}: ${post.text.slice(0, 120)} ${post.url}` }),
    });
}
```

#### Build a topic table of an account's last 300 posts (Python, CSV export)

```python
import csv
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("silentflow/weibo-scraper").call(run_input={
    "profiles": ["https://weibo.com/rmrb"],
    "maxItems": 300,
    "includeReposts": False,
})
posts = list(client.dataset(run["defaultDatasetId"]).iterate_items())

likes, uses = Counter(), Counter()
for p in posts:
    for topic in p["topics"]:
        uses[topic] += 1
        likes[topic] += p["likesCount"]

with open("topics.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["topic", "posts", "likes", "likes_per_post"])
    for topic, n in uses.most_common():
        writer.writerow([topic, n, likes[topic], round(likes[topic] / n)])
```

### 📈 Performance

Measured on 20 September 2026 on real profiles.

| Run | Rows | Time |
|-----|------|------|
| 1 personal profile, 50 latest posts, long posts read in full (the default input) | 50 | 13 seconds |
| 1 media profile, 12 own posts, preview text, plus 2 posts by address | 14 | 5 seconds |
| 1 media profile, every post of the last day, long posts read in full | 35 | 14 seconds |

| Metric | Value |
|--------|-------|
| Fields per row | 33 |
| Posts per timeline page | 45 |
| Columns filled on the default run | all, except `location` (long posts and posts by address), `userDescription` (accounts with a bio) and the media and repost fields that depend on the post |
| Limit per run | no fixed limit: the cap is per profile, and you choose it |

### 💾 Data export

Every run stores its rows in a dataset you can download as JSON, CSV, Excel, XML or HTML from the Storage tab, or pull from the API:

```
https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv&token=YOUR_TOKEN
```

The dataset has two ready-made table views: **Posts** (post, author, published, likes, comments, reposts, URL) and **Author stats** (author, verified, verification, followers, following, posts, gender, profile URL). Schedules, webhooks and the Apify integrations (Google Sheets, Slack, Zapier, Make, n8n) work on top of the same dataset.

### 💡 Tips for best results

1. **Monitoring? Use `publishedAfter` with an age.** `"publishedAfter": "1 day"` on a daily schedule reads only the top of each profile and returns only new posts.
2. **Use user ids for long-lived pipelines.** A nickname or a custom address can change. The numeric id never does, and every row gives it to you in `userId`.
3. **Keep full text on when the text matters.** Long posts, the region and exact counts come with it. Turn it off only for a fast inventory of what an account posted.
4. **Turn reposts off to measure an account's own voice.** Engagement on a repost belongs partly to the original. `includeReposts: false` keeps the rows the account wrote itself.
5. **Download videos in the same run.** `videoUrl` expires within hours. `url`, `images` and `videoCoverUrl` are the links to keep.
6. **Group rows by `userId` for account-level reports.** The author block is identical on every row of a profile, so the first row of each group is the account's profile.

### ❓ FAQ

**What does this scraper extract?**
Every public post of the profiles you list, one row each, with 33 fields: the post (text, exact time, reposts, comments, likes, topics, mentions, source, region, pictures, video), the original it reposts, and its author (name, verification, bio, gender, followers, following, total posts, avatar). It also reads single posts by address.

**What can I type in the profile field?**
A profile address in any form (`weibo.com/u/{id}`, `weibo.com/{alias}`, `weibo.com/n/{nickname}`, `m.weibo.cn/u/{id}`, `m.weibo.cn/profile/{id}`), a numeric user id or a nickname. Anything else is skipped and named in the run log.

**Do I need a Weibo account?**
No. The scraper reads public profiles and posts. There is no login, no browser session and no key to manage.

**How fresh is the data?**
Live. Every run reads Weibo at run time, nothing is served from a cache. `scrapedAt` tells you when each row was read.

**Is there a limit on the number of posts?**
No fixed limit. `maxItems` is per profile, and a run walks a timeline page by page, 45 posts per page, until that cap, the date floor or the end of the profile.

**Can I scrape many profiles in one run?**
Yes. List as many profiles as you need. A profile named twice, for instance once by id and once by address, is read once, and no post is ever delivered twice in a run.

**How do the filters combine?**
They stack. `publishedAfter: "30 days"` with `includeReposts: false` and `maxItems: 100` returns up to 100 posts the account wrote itself in the last 30 days, newest first.

**Why is `location` null on most rows?**
Weibo shows the region of a post on the post's own page, not in the timeline. It is read together with the full text of long posts and for every post read by address. For the region of a specific short post, put its address in `postUrls`.

**Does it search by keyword, read comments or the hot search board?**
No. This scraper is about profiles and posts. Keyword search, comments and trending boards are different products.

**What if a profile does not exist, is private or has no post?**
No row is written for it. The run log names the profile, and a run that ends with no rows at all says why on the run itself. Your dataset never contains error rows. An account that restricts its timeline to logged-in visitors is reported as not found.

**Are the URLs permanent?**
`url` and `userUrl` are permanent. Picture links stay valid as long as the post keeps them. `videoUrl` is signed and expires within hours.

**What is Weibo?**
Weibo (微博, Sina Weibo) is China's public conversation platform, the domestic counterpart of X (Twitter), with government, media, company and celebrity accounts followed by hundreds of millions of readers. A post is a 微博 (a "weibo"), a repost a 转发, a like a 赞.

### ⚖️ Legal

This Actor extracts publicly available data from Weibo. It does not bypass any login, paywall or CAPTCHA, and it does not download video files. Users are responsible for complying with Weibo's terms of service and with applicable data protection laws (GDPR, CCPA, and PIPL, China's Personal Information Protection Law). The output contains author information that account holders publish themselves (name, bio, gender, avatar) and the names of mentioned users; when you process it as personal data, handle it accordingly. The data returned is informational; verify accuracy for regulated use cases.

### 🔗 Related scrapers

- [Douyin Scraper](https://apify.com/silentflow/douyin-scraper): videos and profiles from Douyin, China's TikTok.
- [X Tweet Scraper](https://apify.com/silentflow/x-tweet-scraper): the tweets of any public X (Twitter) profile.
- [YouTube Channel Scraper](https://apify.com/silentflow/youtube-channel-scraper): every video, short and live stream of a channel.
- [TikTok Scraper](https://apify.com/silentflow/tiktok-scraper): videos and profiles from TikTok.

### 📬 Support

Need something this scraper does not do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing details live on the Monetization tab of the actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

The profiles to read, one per line. Paste a profile address (<code>https://weibo.com/u/1749127163</code>, <code>https://weibo.com/leijun</code>), a numeric user id (<code>1749127163</code>) or a nickname (<code>雷军</code>). Every post of every profile becomes one row, newest first. A profile shows 45 posts per page, so 50 posts take a few seconds.

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

Single posts to read, one per line: a post address (<code>https://weibo.com/1749127163/RiOrRC766</code>, <code>https://m.weibo.cn/detail/5344838319083750</code>) or a post id. Each post becomes one row with its full text, exact counts, region and the original it reposts. Leave empty when you only read profiles.

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

How many rows to save for each profile. <code>50</code> covers about a week of a busy media account or a few months of a personal one. Posts read by address do not count.

## `publishedAfter` (type: `string`):

Only keep posts published after this date. Pick a date (<code>2026-01-31</code>) or an age (<code>7 days</code>, <code>3 months</code>). The timeline is read newest first and stops at the first older post, which makes a daily schedule fast: <code>1 day</code> returns only what is new since yesterday.

## `includeReposts` (type: `boolean`):

On: reposts are rows too, with the original post in <code>repostOf</code> (author, text, pictures, counts). Off: only the profile's own posts are saved. A personal account often reposts a third of what it publishes.

## `includeFullText` (type: `boolean`):

On: a post the timeline cuts short (about a fifth of a media account's posts) is read again in full, with its exact counts and the region it was posted from. Off: a faster listing that keeps the preview text of long posts. A long post that cannot be read again is still saved with its preview.

## `debugMode` (type: `boolean`):

Adds detailed lines to the run log. Leave it off for normal runs.

## Actor input object example

```json
{
  "profiles": [
    "https://weibo.com/u/1749127163"
  ],
  "maxItems": 50,
  "includeReposts": true,
  "includeFullText": true,
  "debugMode": false
}
```

# Actor output Schema

## `posts` (type: `string`):

Every post with id, url, text, topics, mentions, source, createdAt, repostsCount, commentsCount, likesCount, location, images, videoUrl, the original of a repost and the full author block.

## `authors` (type: `string`):

The author columns of each row: name, verification, followers, following, posts, gender and profile URL.

# 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 = {
    "profiles": [
        "https://weibo.com/u/1749127163"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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 = { "profiles": ["https://weibo.com/u/1749127163"] }

# Run the Actor and wait for it to finish
run = client.actor("silentflow/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 '{
  "profiles": [
    "https://weibo.com/u/1749127163"
  ]
}' |
apify call silentflow/weibo-scraper --silent --output-dataset

```

## MCP server setup

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