# Weibo Scraper: Weibo Search, Hot Search, Comments, Profiles (`hyperbach/weibo-scraper`) Actor

Weibo (微博) scraper, no login: weibo posts by id or link with the full long text, weibo profiles with exact followers, search by keyword or #topic#, comments and replies, likers, followers and following, the 微博热搜 hot search board with changes between runs. Optional sentiment, translation.

- **URL**: https://apify.com/hyperbach/weibo-scraper.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (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 $2.50 / 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: Weibo Search, Hot Search, Comments, Profiles

**Weibo (微博) data without a login: posts by id or link with the full long text, exact profiles by id, link or screen name, keyword and #topic# search, comments and replies, likers, followers and following, the hot-search boards with their changes between runs, the hot timeline — one row per entity, and a free row that says why for an input that names nothing.** Run it **[on a schedule](https://apify.com/hyperbach/weibo-scraper/examples/monitor-weibo-brand-keywords-for-new-posts)** and each run delivers only the posts no earlier run delivered. Optional sentiment tags and machine translation. No account, no cookie, no browser, proxies handled for you.

### Why this Weibo scraper

- **The full long text, every time.** Weibo's list pages cut a long post at about 140 characters. In our test of the lane two rivals delivered the cut text as the post. Here every post you name is read whole, and a long post found by search, on a timeline or on the hot timeline is read in full too (`fetchFullText`: 49 of 49 long search posts in our test); the few Weibo will not serve are flagged `text_truncated`.
- **Exact where Weibo is exact, honest where it rounds.** A profile row carries the exact follower integer (168,220,053 for 微博小秘书 at the time of writing) where the mobile pages show "1.68亿". A count Weibo only shows rounded is delivered as a number next to the text as written, with a precision word, never passed off as exact. Ready-made: [Weibo exact follower counts for a list of accounts](https://apify.com/hyperbach/weibo-scraper/examples/weibo-exact-follower-counts-for-a-list-of-accounts).
- **One run, any mix.** Post ids and links, user ids, links and screen names, keywords and #topics#, the boards and the hot timeline in one run; the same post given in 13 forms (ids, mobile, desktop, share, wrapped and old links) was one row in our test, and a user given twice is charged once; every input that names nothing comes back as a free row that says why (not found, invalid, empty).
- **Depth where a visitor has it.** Comments to the post's own count (98 % of a 1,577-comment post in our test), replies, likers to 200, following to the full count, fans to the first thousands, a user's videos; the four hot boards with rank, heat, label, category and the promoted entries flagged; the hot timeline (about 100 posts). Not here, because Weibo keeps them behind its login: search past page 1 or by date, a user's posts past the newest 10, the list of reposts. Ready-made: [Scrape a Weibo post: full text, comments, replies and likers](https://apify.com/hyperbach/weibo-scraper/examples/scrape-weibo-post-comments-replies-and-likers).
- **Built for schedules.** `onlyNew` delivers only posts no earlier run delivered; with the memory on, every hot-board row but a promoted entry says whether it is new, rising, falling or steady since the last run, and a row is written for each word that dropped off — never a guess about why. Ready-made: [Weibo hot search (热搜): trending words, top posts, rank changes](https://apify.com/hyperbach/weibo-scraper/examples/weibo-hot-search-board-top-posts-and-rank-changes).
- **Says what Weibo hides.** Weibo counts replies it does not list to a visitor: on a 1,579-comment post it listed none of the replies of 21 of the 28 comments that had replies (75 %). The post row says so in `comments_note`; a liker list that ends before the like count says so in `likers_note`; a list Weibo shows only page 1 of says so in `list_note`.
- **Light and fast.** Plain JSON, no browser: about 4 KB per post, 2 KB per profile; 500 rows in 30 seconds on one exit in our test, 0.84–1.68 s a search post with its full text; paced under Weibo's per-IP limit and rotated on the first refusal.

### Who it's for

- **Marketers and brand teams** — what Weibo says about a brand or campaign today: keyword and topic search across the tabs, comments with the commenters' regions, the hot boards, sentiment tags.
- **Researchers and analysts** — posts with complete text and counts, exact profiles, comment threads, the hot-search board with heat and categories, in one row shape per entity.
- **Monitoring teams** — a scheduled keyword list or board read that delivers only what is new and says what moved on the board since the last run.
- **Developers and agents** — typed fields, one row per input in input order, a free labelled row for every miss, and a run summary to check a pipeline against.

### Quick start

**Posts by id or link, with their full text**

```json
{
  "posts": [
    "5346699644242007",
    "https://weibo.com/1642909335/RjAS0hNxt"
  ]
}
```

**Exact profiles by id, link or screen name**

```json
{
  "users": [
    "1642909335",
    "https://weibo.com/u/2803301701",
    "@人民日报"
  ],
  "includeUserDetails": true
}
```

**A keyword across the search tabs, and a #topic#**

```json
{
  "keywords": [
    "亚运会",
    "#热聊亚运会#"
  ],
  "searchTabs": [
    "all",
    "realtime",
    "videos"
  ],
  "maxPostsPerKeyword": 50
}
```

**A post with its comments and likers**

```json
{
  "posts": [
    "5346699644242007"
  ],
  "maxCommentsPerPost": 200,
  "includeReplies": true,
  "maxLikersPerPost": 100
}
```

**The hot-search boards and the hot timeline**

```json
{
  "hotBoards": [
    "realtime",
    "entertainment",
    "topics",
    "social"
  ],
  "hotTimelinePosts": 50
}
```

**A daily monitor: new posts only, board changes**

```json
{
  "keywords": [
    "亚运会"
  ],
  "hotBoards": [
    "realtime"
  ],
  "onlyNew": true,
  "stateStoreName": "my-weibo-watch"
}
```

### Output

Four row types share one dataset (`row_type` says which): `post`, `user` (an exact profile or a listed user), `comment`, `hot_item`:

| field | meaning |
|---|---|
| `row_type` | `post`, `user`, `comment` or `hot_item`: which columns of the row are filled. |
| `input` | The value you gave that this row answers (the first form, when the same post or user was given several ways); on a search row the keyword; empty on board rows. |
| `input_index` | The 1-based position of the input in its list (`posts`, `users` or `keywords`). |
| `inputs_merged` | Other forms of the same post or user you gave (a mid and a link of one post), merged into this row. |
| `source_kind` | Where the row came from: `post` (a post you named), `search`, `topic`, `timeline`, `hot_timeline`, `hot_topic`, `user_videos`, `profile`, `author`, `followers`, `following`, `likers`, `comments`, `hot_board`. |
| `status` | `ok` = a delivered record; `not_found`, `invalid`, `empty`, `failed`, `duplicate` = a free row that says why there is no record for this input. |
| `status_detail` | Why a row is not `ok`, in words (Weibo's own message where it gave one). |
| `scraped_at` | When this row was read (UTC). |
| `query` | The keyword, topic or hot-board word this row was found for. |
| `search_tabs` | The search tabs the post appeared in (`all`, `realtime`, `hot`, `videos`, `pictures`, `topic`). |
| `list_note` | What the list this row came from shows a visitor (page 1 only; the newest 10 posts). |
| `mid` | The post's 16-digit id, as a string. |
| `bid` | The post's 9-character id used in links (`weibo.com/<uid>/<bid>`). |
| `post_url` | The post's link on weibo.com. |
| `created_at` | When the post was published, Beijing time with its zone (`2026-09-24T15:46:35+08:00`). |
| `created_at_utc` | The same moment in UTC. |
| `text` | The post's text, plain: the full long text (a cut text is flagged in `text_truncated`), emoticons as `[name]`, line breaks kept. |
| `text_html` | The text as Weibo serves it (HTML with the hashtag, mention and emoticon markup). |
| `is_long_text` | Weibo marks the post as a long post (its list rows show about 140 characters). |
| `text_truncated` | `true` when the row carries a cut text: the long post was not read in full (`fetchFullText` off, or Weibo did not serve it). |
| `text_length` | Characters in `text`. |
| `reposts_count` | Reposts of the post. |
| `comments_count` | Comments on the post, as Weibo counts them (roots and replies). |
| `likes_count` | Likes (attitudes) on the post. |
| `pictures` | The post's pictures, largest size URLs. |
| `picture_count` | How many pictures the post has. |
| `video_url` | The post's video (720p where served, else HD); a signed URL that expires in about an hour. |
| `video_hd_url` | The HD stream of the video (signed, expires in about an hour). |
| `video_duration_s` | The video's length in seconds. |
| `video_title` | The video's title or caption. |
| `video_play_count` | Plays of the video as Weibo shows them (`1万次播放`). |
| `region` | The IP region Weibo shows for the post (发布于 …), without the prefix. |
| `source_client` | The client the post was sent from (微博网页版, iPhone客户端 …). |
| `hashtags` | The `#topics#` in the text, without the marks. |
| `mentions` | The `@users` named in the text. |
| `links` | The links in the text. |
| `is_repost` | The post reposts another post. |
| `repost_of` | The original post of a repost, in the same shape (mid, text, counts, pictures, video, the author's id and name). |
| `edit_count` | How many times the post was edited, where Weibo shows it. |
| `is_ad` | Weibo marks the post as promoted. |
| `matches_query` | On a search row: the keyword appears in the text, the hashtags or the reposted original (Weibo's 综合 tab also ranks related posts). |
| `author_uid` | The author's user id. |
| `author_name` | The author's screen name. |
| `author_url` | The author's profile link. |
| `author_avatar_url` | The author's avatar. |
| `author_verified` | The author is verified. |
| `author_verified_type` | Weibo's verification type code (0 personal, 1–7 organisation, 220 none). |
| `author_verified_reason` | The verification text shown on the author's profile. |
| `author_followers` | The author's followers as the post page shows them: a number read from "1.68亿"-style text above 10,000 (see `author_followers_precision`). Empty on a hot-timeline or video-list row unless the post was read in full: those lists do not carry it. |
| `author_followers_shown` | The author's follower count as written (`1.68亿`). |
| `author_followers_precision` | `exact` or `rounded`: whether `author_followers` is the exact integer. The exact integer is on the author's `user` row (`includeAuthorProfiles`). |
| `author_following` | How many accounts the author follows. |
| `author_posts_count` | The author's post count. |
| `author_gender` | `m`, `f` or `n` as Weibo gives it. |
| `author_description` | The author's bio. |
| `comments_requested` | `maxCommentsPerPost` as given. |
| `comments_delivered` | Comment rows delivered for this post. |
| `comments_note` | Why fewer comments than asked were delivered, when so, and how many comments Weibo counts replies under but lists none of to a visitor. |
| `likers_delivered` | Liker rows delivered for this post. |
| `likers_note` | Why fewer likers than asked were delivered, when so: Weibo's liker list for a visitor ended short of the post's like count. |
| `analysis_sentiment` | With `tagPosts`: the text's sentiment from −1 (negative) to 1 (very positive), by a classification model. |
| `analysis_kind` | With `tagPosts`: `news`, `opinion`, `promotion`, `entertainment`, `personal`, `complaint`, `question` or `other`. |
| `analysis_confidence` | With `tagPosts`: the model's confidence in each tag, 0–1. |
| `translation` | With `translateTo`: the machine translation of the text (or of the hot-board word). |
| `translation_note` | Which model made the translation, or why there is none. |
| `raw` | With `includeRaw`: Weibo's own JSON object for the row. |
| `run_tag` | Your `runTag`, copied onto every row. |
| `list_of` | On a listed user: the user id (followers, following) or post id (likers) the list belongs to. |
| `list_kind` | `follower`, `following`, `liker`, `search` or `author`: what kind of list the user row comes from. |
| `list_total` | Weibo's own count of the list (followers, following; the post's like count for likers). It can differ from the profile's follower count: Weibo counts its list apart (188,265,686 on a followers list whose profile said 168,220,042). |
| `uid` | The user's id, as a string. |
| `screen_name` | The user's screen name. |
| `profile_url` | The user's profile link. |
| `avatar_url` | The user's avatar. |
| `cover_url` | The profile's cover image. |
| `verified` | The user is verified. |
| `verified_type` | Weibo's verification type code (0 personal, 1–7 organisation, 220 none). |
| `verified_kind` | `personal`, `organisation` or `none`. |
| `verified_badge` | The V a visitor sees: `blue` (an organisation), `orange` (the gold personal V), `yellow` (a personal V) or `none`. |
| `verified_reason` | The verification text. |
| `gender` | `m`, `f` or `n`. |
| `location` | The location on the profile (profile rows; Weibo's lists of followers, following and likers do not carry it). |
| `description` | The bio; on a topic row, the topic's description. |
| `followers` | Followers: the exact integer on a profile row (`followers_precision` exact); a number read from the rounded text on a listed user. |
| `followers_shown` | The follower count as Weibo writes it (`1.68亿`). |
| `followers_precision` | `exact` (from the profile page) or `rounded` (from a list page). |
| `following` | How many accounts the user follows. |
| `posts_count` | The user's post count. |
| `total_reposts` | Lifetime reposts received, on a profile row. |
| `total_comments` | Lifetime comments received, on a profile row. |
| `total_likes` | Lifetime likes received, on a profile row. |
| `member_rank` | Weibo membership rank (mbrank). |
| `svip` | SVIP level. |
| `birthday` | With `includeUserDetails`: the birthday as shown (`1948-06-15 双子座`). |
| `registered_at` | With `includeUserDetails`: when the account was created. |
| `ip_location` | With `includeUserDetails`: the IP region on the profile, where Weibo serves it. Weibo serves none to a visitor (empty on 17 of 17 profiles we read, 2026-10-08), so the column is empty for now; a post's own region is in `region`. |
| `credit_level` | With `includeUserDetails`: the sunshine credit level. |
| `company` | With `includeUserDetails`: the company on the profile. |
| `school` | With `includeUserDetails`: the school on the profile. |
| `labels` | With `includeUserDetails`: the profile's labels (活跃 tags, awards). |
| `details_note` | Why the details could not be read, when so. |
| `posts_requested` | `maxPostsPerUser` as given. |
| `posts_delivered` | Timeline post rows delivered for this user. |
| `posts_note` | What the timeline shows a visitor, and why fewer rows when so. |
| `followers_delivered` | Follower rows delivered for this user. |
| `following_delivered` | Following rows delivered for this user. |
| `videos_delivered` | Video post rows delivered for this user. |
| `post_mid` | On a comment: the post it belongs to. |
| `comment_id` | The comment's id. |
| `parent_comment_id` | On a reply: the root comment it belongs to. |
| `is_reply` | The row is a reply to a comment. |
| `reply_to_comment_id` | On a reply: the comment it answers (a root or another reply). |
| `like_count` | Likes on the comment. |
| `reply_count` | Replies under the comment, as Weibo counts them (root comments only). |
| `floor` | The comment's floor number. |
| `user_uid` | The commenter's user id. |
| `user_name` | The commenter's screen name. |
| `user_url` | The commenter's profile link. |
| `user_verified` | The commenter is verified. |
| `user_verified_type` | The commenter's verification type code. |
| `user_verified_reason` | The commenter's verification text. |
| `user_followers` | The commenter's followers (exact, from the comment page). |
| `user_following` | How many accounts the commenter follows (from the comment page). |
| `user_posts_count` | The commenter's post count (from the comment page). |
| `user_total_likes` | The likes the commenter's posts have received over the account's life (from the comment page). |
| `user_location` | The commenter's profile location. |
| `user_gender` | The commenter's gender code. |
| `user_description` | The commenter's bio. |
| `board` | `realtime`, `entertainment`, `topics`, `social`, or `search_topics` for a topic found by the search's 话题 tab. |
| `rank` | The position on the board (0 = the pinned topic; empty on a promoted entry or a dropped word). |
| `word` | The hot word or topic. |
| `heat` | Weibo's heat number for the entry (the read count on the topics board). |
| `label` | The board's label: 新 (new), 热 (hot), 沸 (boiling), 爆; a grade on the entertainment board. |
| `category` | The category Weibo files the entry under (体育, 艺人 …). |
| `onboard_time` | When the entry came onto the board (UTC), where Weibo gives it. |
| `is_pinned` | The pinned (government) topic at the top of the board. |
| `is_hot` | Weibo's hot flag on the entry. |
| `star_name` | The celebrity Weibo links the entry to, where given. |
| `subject_label` | Weibo's subject label on the entry. |
| `topic_url` | The search page of the word on s.weibo.com. |
| `read_count` | Reads of the topic (topics board, topic search). |
| `mention_count` | Discussions / mentions of the topic. |
| `claim` | Who hosts the topic (topics board). |
| `summary` | Weibo's summary of the topic (topics board). |
| `change_type` | With the memory on: `new`, `rising`, `falling`, `steady` or `dropped` since the last delivered board; empty on the first read and on a promoted entry (Weibo shows a different ad on almost every read, so an ad is never new or dropped). |
| `previous_rank` | The entry's rank on the last delivered board. |
| `rank_change` | Places risen (positive) or fallen since the last delivered board. |
| `previous_heat` | The heat on the last delivered board. |
| `heat_change` | The heat's change since the last delivered board. |
| `first_seen_at` | When this memory first saw the word on the board (UTC). |

Example record:

```json
{
  "row_type": "post",
  "input": "5346699644242007",
  "input_index": 1,
  "inputs_merged": [
    "https://m.weibo.cn/detail/5346699644242007",
    "https://weibo.com/1642909335/RjAS0hNxt"
  ],
  "source_kind": "post",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-08T07:50:53Z",
  "query": null,
  "search_tabs": null,
  "list_note": null,
  "mid": "5346699644242007",
  "bid": "RjAS0hNxt",
  "post_url": "https://weibo.com/1642909335/RjAS0hNxt",
  "created_at": "2026-09-24T15:46:35+08:00",
  "created_at_utc": "2026-09-24T07:46:35Z",
  "text": "🔥名古屋亚运会激战正酣，中秋月圆登场！乒乓球团体决赛、田径飞人大战轮番上演！\n\n💰@微博热点 金橙V专属限时激励来了！9月24日-28日，带#热聊亚运会#发布原创/二创视频（不得搬运、套作、抄袭），每日综合热度TOP 10每条奖励100元！\n\n🎯推荐创作方向：赛场高光时刻——乒乓球夺金名场面、关键球战术拆解、田径冲刺破纪录瞬间；亚运中秋夜——运动员过节花絮、赛场内外温情时刻、趣味内容二创等。\n\n🥮月满名古屋，连续5日独立结算，天天都有机会上榜！发视频，上场！\n\n更多活动信息详见：网页链接",
  "text_html": "🔥名古屋亚运会激战正酣，中秋月圆登场！乒乓球团体决赛、田径飞人大战轮番上演！<br /><br />💰<a href='/n/微博热点'>@微博热点</a> 金橙V专属限时激励来了！9月24日-28日，带<a  href=\"https://m.weibo.cn/search?containerid=231522type%3D1%26t%3D10%26q%3D%23%E7%83%AD%E8%81%8A%E4%BA%9A%E8%BF%90%E4%BC%9A%23&extparam=%23%E7%83%AD%E8%81%8A%E4%BA%9A%E8%BF%90%E4%BC%9A%23&launchid=10000360-page_H5\" data-hide=\"\"><span class=\"surl-text\">#热聊亚运会#</span></a>发布原创/二创视频（不得搬运、套作、抄袭），每日综合热度TOP 10每条奖励100元！<br /><br />🎯推荐创作方向：赛场高光时刻——乒乓球夺金名场面、关键球战术拆解、田径冲刺破纪录瞬间；亚运中秋夜——运动员过节花絮、赛场内外温情时刻、趣味内容二创等。<br /><br />🥮月满名古屋，连续5日独立结算，天天都有机会上榜！发视频，上场！<br /><br />更多活动信息详见：<a  href=\"https://weibo.com/1642909335/RiospyQov\" data-hide=\"\"><span class='url-icon'><img style='width: 1rem;height: 1rem' src='https://h5.sinaimg.cn/upload/2015/09/25/3/timeline_card_small_web_default.png'></span><span class=\"surl-text\">网页链接</span></a>",
  "is_long_text": true,
  "text_truncated": false,
  "text_length": 246,
  "reposts_count": 14,
  "comments_count": 110,
  "likes_count": 56,
  "pictures": [
    "https://wx1.sinaimg.cn/mw2000/001NbtLFgy1ihet31cky4j60h82vmdo302.jpg"
  ],
  "picture_count": 1,
  "video_url": null,
  "video_hd_url": null,
  "video_duration_s": null,
  "video_title": null,
  "video_play_count": null,
  "region": "北京",
  "source_client": "微博网页版",
  "hashtags": [
    "热聊亚运会"
  ],
  "mentions": [
    "微博热点"
  ],
  "links": [
    "https://weibo.com/1642909335/RiospyQov"
  ],
  "is_repost": false,
  "repost_of": null,
  "edit_count": null,
  "is_ad": false,
  "matches_query": null,
  "author_uid": "1642909335",
  "author_name": "微博小秘书",
  "author_url": "https://weibo.com/u/1642909335",
  "author_avatar_url": "https://wx1.sinaimg.cn/orj480/001NbtLFly8hyj3qdyilqj60go0gojrz02.jpg",
  "author_verified": true,
  "author_verified_type": 7,
  "author_verified_reason": "微博官方账号",
  "author_followers": 168000000,
  "author_followers_shown": "1.68亿",
  "author_followers_precision": "rounded",
  "author_following": 2949,
  "author_posts_count": 10072,
  "author_gender": "f",
  "author_description": "对微博的任何问题请私信@微博客服，或访问客服中心→http://kefu.weibo.com",
  "comments_requested": 20,
  "comments_delivered": 20,
  "comments_note": null,
  "likers_delivered": 39,
  "likers_note": "Weibo's liker list for a visitor ended at page 3: 39 of the post's 56 likes listed",
  "analysis_sentiment": null,
  "analysis_kind": null,
  "analysis_confidence": null,
  "translation": null,
  "translation_note": null,
  "raw": null,
  "run_tag": null,
  "list_of": null,
  "list_kind": null,
  "list_total": null,
  "uid": null,
  "screen_name": null,
  "profile_url": null,
  "avatar_url": null,
  "cover_url": null,
  "verified": null,
  "verified_type": null,
  "verified_kind": null,
  "verified_badge": null,
  "verified_reason": null,
  "gender": null,
  "location": null,
  "description": null,
  "followers": null,
  "followers_shown": null,
  "followers_precision": null,
  "following": null,
  "posts_count": null,
  "total_reposts": null,
  "total_comments": null,
  "total_likes": null,
  "member_rank": null,
  "svip": null,
  "birthday": null,
  "registered_at": null,
  "ip_location": null,
  "credit_level": null,
  "company": null,
  "school": null,
  "labels": null,
  "details_note": null,
  "posts_requested": null,
  "posts_delivered": null,
  "posts_note": null,
  "followers_delivered": null,
  "following_delivered": null,
  "videos_delivered": null,
  "post_mid": null,
  "comment_id": null,
  "parent_comment_id": null,
  "is_reply": null,
  "reply_to_comment_id": null,
  "like_count": null,
  "reply_count": null,
  "floor": null,
  "user_uid": null,
  "user_name": null,
  "user_url": null,
  "user_verified": null,
  "user_verified_type": null,
  "user_verified_reason": null,
  "user_followers": null,
  "user_following": null,
  "user_posts_count": null,
  "user_total_likes": null,
  "user_location": null,
  "user_gender": null,
  "user_description": null,
  "board": null,
  "rank": null,
  "word": null,
  "heat": null,
  "label": null,
  "category": null,
  "onboard_time": null,
  "is_pinned": null,
  "is_hot": null,
  "star_name": null,
  "subject_label": null,
  "topic_url": null,
  "read_count": null,
  "mention_count": null,
  "claim": null,
  "summary": null,
  "change_type": null,
  "previous_rank": null,
  "rank_change": null,
  "previous_heat": null,
  "heat_change": null,
  "first_seen_at": null
}
```

### Pricing

**Pay only for the rows a run delivers**, with no start fee and no platform usage billed to you. Prices fall with your Apify plan.

| per 1,000 | Free | Starter | Scale | Business |
|---|---|---|---|---|
| Post (`post`) | $5.00 | $4.25 | $3.50 | $2.50 |
| Profile (`profile`) | $5.00 | $4.25 | $3.50 | $2.50 |
| Comment (`comment`) | $5.00 | $4.25 | $3.50 | $2.50 |
| Listed user (`user`) | $5.00 | $4.25 | $3.50 | $2.50 |
| Hot-board row (`hot_item`) | $4.60 | $3.91 | $3.22 | $2.30 |
| Sentiment and kind tags (`post_tags`) | +$1.00 | +$0.85 | +$0.70 | +$0.50 |
| Translation (`translation`) | +$3.00 | +$2.55 | +$2.10 | +$1.50 |

A post, an exact profile, a comment or reply, or a listed user (a follower, a following, a liker, a user found by search) is **$5.00 per 1,000 rows** on the Free plan and $2.50 on Business; a hot-board row is $4.60 per 1,000, so one read of the realtime board (about 52 rows) is about $0.24 on Free. The `+` fees are charged **only on a row that carries the thing**: with `tagPosts`, a post or comment row with its sentiment and kind tags ($1.00 per 1,000 such rows on Free); with `translateTo`, a post, comment or board row with its translation ($3.00 per 1,000). Free: a row for an input that names nothing (a post or user that does not exist, a value that is not a Weibo id, link or keyword, an empty search, a duplicate of an earlier input), a search tab Weibo did not serve, a post `onlyNew` skips, and a run that failed before its first row; a run that stops early (a timeout, an abort) is charged for the rows it delivered. `maxItems` counts the five row types together and is exact; before the first request the log says the most the run can cost at your plan's prices, and your charge limit stops the run before it is passed. Enterprise plans have their own rates — the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **Posts and profiles** — Paste post ids (16-digit mids or 9-character bids) or any post link in `posts`; user ids, profile links or screen names in `users`. Each comes back as one row in your order (`input_index`), or as a free `not_found` / `invalid` row. Add `maxCommentsPerPost`, `maxLikersPerPost`, `maxPostsPerUser` (the newest 10 is all a visitor sees), `maxFollowersPerUser`, `maxFollowingPerUser`, `maxVideosPerUser` and `includeUserDetails` for the rows behind each entity; `includeAuthorProfiles` adds the exact profile of every author. A user's video rows carry signed video links that expire in about an hour: save the files soon. Ready-made: [Weibo account videos: video links, duration, title, plays](https://apify.com/hyperbach/weibo-scraper/examples/weibo-account-videos-with-video-links).
- **Comments, replies and likers** — `maxCommentsPerPost` reads the comments of every post row, newest first (`commentsOrder` time) or in Weibo's ranking (hot). Each comment row carries its text, time, likes, region and pictures, and the commenter's exact followers, following, posts, lifetime likes and verification (`user_*`). The replies Weibo shows under a comment on the comments page come as comment rows (charged) even with `includeReplies` off; `includeReplies` reads the rest, one request per comment, counted in `maxCommentsPerPost`. `maxLikersPerPost` adds the users who liked the post (to 200); a liker list can end before the like count (39 of 56 for one post, on every read), and the post row then says so in `likers_note`, as `comments_note` does for comments. Ready-made: [Scrape a Weibo post: full text, comments, replies and likers](https://apify.com/hyperbach/weibo-scraper/examples/scrape-weibo-post-comments-replies-and-likers).
- **Search** — A keyword reads page 1 of each tab in `searchTabs` (about 10–15 posts a tab, about 50 on 图片 pictures; `users` gives about 20 user rows with the `verified_badge`, `topics` up to 10 topic rows with discussion and read counts, each topic once); a `#topic#` reads the topic page. Weibo shows a visitor page 1 only and no date window: a row's `list_note` says so, and `matches_query` says whether the keyword is in the text. For many posts on a subject, search several related keywords and tabs. Ready-made: [Find Weibo accounts and #topics# for a keyword (KOL search)](https://apify.com/hyperbach/weibo-scraper/examples/find-weibo-accounts-and-topics-for-a-keyword).
- **Hot search** — `hotBoards` reads the 热搜 realtime board (50 words, the pinned topic at rank 0, promoted entries flagged `is_ad`), the 文娱 board (50), the 话题 board (10 topics with read and mention counts) and the 社会 board (50); `postsPerHotTopic` adds the top posts of Weibo's 综合 search behind each ranked realtime word (a post two words share is one row, and the second word takes its next post); `hotTimelinePosts` reads Weibo's hot timeline. With `stateStoreName` set, every board row carries its change since the last run and dropped words get their own rows. Ready-made: [Weibo hot search (热搜): trending words, top posts, rank changes](https://apify.com/hyperbach/weibo-scraper/examples/weibo-hot-search-board-top-posts-and-rank-changes).
- **Add-ons** — `tagPosts` adds `analysis_sentiment` (−1 to 1) and `analysis_kind` to every post and comment row from a classification model; `translateTo` adds a machine translation of posts, comments and hot words by an OpenAI model, next to the original and labelled as such. Both are charged per row they land on. Ready-made: [Weibo posts about brands in English, with sentiment tags](https://apify.com/hyperbach/weibo-scraper/examples/weibo-posts-in-english-with-sentiment-for-brands).
- **A schedule** — Save a task with your keywords and `onlyNew` and schedule it: each run reads page 1 of the tabs you chose and delivers only the posts no earlier run of the task delivered; a post skipped this way is free, so a run with nothing new costs nothing. Weibo shows a visitor no older page, so a busy word wants an hourly run. `stateStoreName` names the memory; with `hotBoards` it also gives every board row its change since the last run. Ready-made: [Monitor Weibo for brand keywords: new posts only](https://apify.com/hyperbach/weibo-scraper/examples/monitor-weibo-brand-keywords-for-new-posts).

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `posts` | `array` | `[]` | Weibo posts, one per line, in any form: the 16-digit id (mid) `5346699644242007`, the 9-character id (bid) `RjAS0hNxt`, or a link such as `https://weibo.com/1642909335/RjAS0hNxt`, `https://m.weibo.cn/detail/5346699644242007`, `https://m.weibo.cn/status/RjAS0hNxt`. One row per post: the same post given several ways is one row. A value that is not a Weibo post id or link comes back as a free row that says why. |
| `users` | `array` | `[]` | Weibo users, one per line: the numeric id `1642909335`, a profile link `https://weibo.com/u/1642909335`, `https://weibo.com/1642909335`, `https://m.weibo.cn/u/1642909335`, `https://weibo.com/n/微博小秘书`, or a screen name `微博小秘书` / `@微博小秘书`. One exact profile row per user (the exact follower integer, not the rounded "1.68亿"). |
| `keywords` | `array` | `[]` | Search terms, one per line. A plain word or phrase reads page 1 of each tab in `searchTabs` (about 10–15 posts a tab, about 50 on 图片 pictures); `#topic#` reads the topic page instead. Weibo shows a visitor page 1 only and no date window: the rows say so. |
| `searchTabs` | `array` | `[]` | The search tabs read for each keyword, page 1 each; empty = `all` (综合). A post found in two tabs is one row with both tabs in `search_tabs`. `users` gives `user` rows, `topics` gives up to 10 `hot_item` rows with discussion and read counts, each topic once; the other tabs give `post` rows. |
| `maxPostsPerKeyword` | `integer` | `0` | The most post rows per keyword over its tabs (0 = every post of the pages read: about 90 over the five post tabs). |
| `hotBoards` | `array` | `[]` | The hot-search boards to read, one `hot_item` row per entry: rank, word, heat, label (新 / 热 / 沸), category, time on board, the pinned topic and promoted entries flagged. With the memory on (`stateStoreName` or `onlyNew`), each row says how it moved since the last run (new, rising, falling, steady) and a row is written for each word that dropped off. |
| `postsPerHotTopic` | `integer` | `0` | For each ranked word of the realtime board, the top posts of Weibo's 综合 search for it (one search page per word; the pinned topic and promoted entries are skipped; a post two words share is one row, and the second word takes the next post of its page; needs `realtime` in `hotBoards`); 0 = none. |
| `hotTimelinePosts` | `integer` | `0` | How many posts of Weibo's hot (trending) timeline to deliver, 10 a page; 0 = none. The walk ends when a page adds nothing new (about 100 posts in practice). |
| `fetchFullText` | `boolean` | `true` | A search, timeline or hot-timeline row cuts a long post at about 140 characters; with this on, each such post is read in full (one request per long post). Off, the row keeps the cut text and `text_truncated` is true. |
| `includeAuthorProfiles` | `boolean` | `false` | After the posts, one exact `user` row per distinct author (the exact follower integer; charged as a profile). Every post row already carries the author's name, id, verification and counts as the post page shows them. |
| `maxCommentsPerPost` | `integer` | `0` | Comment rows per post row (`comment`: text, time, likes, region, the commenter with exact followers), to the post's own count; 0 = none. Applies to every post row of the run. |
| `commentsOrder` | `time` / `hot` | `"time"` | The order Weibo lists the comments in. Time order reaches more of a big post's comments (98 % of 1,577 in our test); hot order follows Weibo's ranking. |
| `includeReplies` | `boolean` | `false` | Read the replies under each comment that has them (one request per such comment), as `comment` rows with `is_reply` and `parent_comment_id`. Counted in `maxCommentsPerPost`. |
| `maxLikersPerPost` | `integer` | `0` | Who liked the post, as `user` rows (`list_kind` liker), up to 200 a post (Weibo shows a visitor no more); 0 = none. |
| `maxPostsPerUser` | `integer` | `0` | The newest posts of each user in `users`, as `post` rows; 0 = the profile only. Weibo shows a visitor the newest 10 and no more. |
| `maxFollowersPerUser` | `integer` | `0` | The user's followers (fans) as `user` rows, 10 a request, with the exact total in `list_total`; 0 = none. Weibo serves a visitor the first few thousand of a big account. |
| `maxFollowingPerUser` | `integer` | `0` | The accounts the user follows, as `user` rows, 10 a request, to the full count; 0 = none. |
| `maxVideosPerUser` | `integer` | `0` | The user's video posts as `post` rows (video URL, duration, title); 0 = none. |
| `includeUserDetails` | `boolean` | `false` | One more request per user in `users`: registration date, credit level and the profile labels, and the birthday, company and school where the user shows them. Weibo shows a visitor no IP location. |
| `tagPosts` | `boolean` | `false` | Typed tags on every post and comment row from a classification model (Jev, pinned version): `analysis_sentiment` (−1 to 1), `analysis_kind` (news, opinion, promotion, entertainment, personal, complaint, question, other) and the confidence of each. Charged per tagged row. |
| `translateTo` | `string` | `""` | A language code (`en`, `de`, `ja`, `pt-BR`): a machine translation of each post, comment and hot-board word by an OpenAI model, next to the original (`translation`, with the model named in `translation_note`). Empty = no translation. Charged per translated row. |
| `includeRaw` | `boolean` | `false` | Keep Weibo's own JSON object on each row (`raw`), for fields this Actor does not name. |
| `onlyNew` | `boolean` | `false` | Deliver only posts no earlier run of the same task delivered (search, topic, timeline, hot-timeline and video rows); turns the memory on. Hot-board rows then carry their change since the last run. |
| `stateStoreName` | `string` | `""` | Name of the memory between runs. Given, it turns the memory on: hot-board rows get `change_type`, `previous_rank`, `rank_change`, `heat_change` and dropped words get their own rows; with `onlyNew`, posts delivered before are skipped. Empty = derived from the inputs when `onlyNew` is on. |
| `maxItems` | `integer` | `0` | The most charged rows this run delivers, all types together. 0 = no limit. Free rows (not found, invalid, empty) do not count. |
| `proxyUrl` | `string` |  | `http://user:pass@host:port` — a proxy of yours to read Weibo through, tried before the Actor's own exits. Leave empty: the Actor brings its own proxies and no Chinese exit is needed. |
| `runTag` | `string` | `""` | A label copied onto every row (`run_tag`), to tell runs apart in a shared dataset. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A search that matches nothing is not an error: the dataset is empty and nothing is charged. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Can it read a user's older posts, or search by date range?**

No. Weibo shows a visitor the newest 10 posts of a user, page 1 of each search tab, and no date filter; the rest is behind a login, and this Actor does not log in or take a cookie. The rows say so (`list_note`). Comments, likers, following, fans and a user's videos go deeper because Weibo serves those lists to a visitor.

**Are the follower counts exact?**

On a `user` row from `users` or `includeAuthorProfiles`, yes: `followers` is the exact integer and `followers_precision` is `exact`. On a post's author block and on listed users (followers, following, likers, search) Weibo serves the rounded text ("1.68亿"): the row keeps it as written in `*_followers_shown` and marks the number `rounded`.

**What is charged?**

Delivered rows: a post, a profile, a comment, a listed user, a hot-board row, and the tag or translation add-on on the rows it lands on. Rows for inputs that name nothing (not found, invalid, empty, duplicate), and a run that failed before its first row, are free; a run that stops early (a timeout, an abort) is charged for the rows it delivered. `maxItems` caps every charged row together.

**Does it need a Chinese proxy or a Weibo account?**

No. The Actor brings its own exits (datacenter IPs are served; six countries were tested) and uses Weibo's visitor access. `proxyUrl` lets you put a proxy of your own in front.

**Why does a comment say replies exist but none are delivered?**

Weibo counts replies under a comment (`reply_count`) but, for many comments, lists none of them to a visitor: on a 1,579-comment post it hid every reply of 21 of the 28 comments that had replies (75 %), on both of its comment routes. The post row's `comments_note` says how many comments that happened to.

**Why are there fewer likers than likes?**

Weibo's liker list for a visitor stops at 200 and can end before the like count (39 of 56 for one post, on every read). The post row then says so in `likers_note`; `list_total` on each liker row is Weibo's own like count.

**Can an AI agent use it (MCP)?**

Yes. Apify's MCP server (`https://mcp.apify.com`) offers Store Actors as tools to Claude, Cursor and other MCP clients: add this Actor and the agent sends `posts`, `users` or `keywords` and gets the rows back. The synchronous API (`run-sync-get-dataset-items`) does the same in one HTTP call.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/weibo-scraper').call({"posts": ["5346699644242007", "https://weibo.com/1642909335/RjAS0hNxt"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/weibo-scraper').call(run_input={'posts': ['5346699644242007', 'https://weibo.com/1642909335/RjAS0hNxt']})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/weibo-scraper --input '{"posts": ["5346699644242007", "https://weibo.com/1642909335/RjAS0hNxt"]}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~weibo-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"posts": ["5346699644242007", "https://weibo.com/1642909335/RjAS0hNxt"]}'
```

### Support

apify@hyperbach.com

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Weibo posts, one per line, in any form: the 16-digit id (mid) `5346699644242007`, the 9-character id (bid) `RjAS0hNxt`, or a link such as `https://weibo.com/1642909335/RjAS0hNxt`, `https://m.weibo.cn/detail/5346699644242007`, `https://m.weibo.cn/status/RjAS0hNxt`. One row per post: the same post given several ways is one row. A value that is not a Weibo post id or link comes back as a free row that says why.

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

Weibo users, one per line: the numeric id `1642909335`, a profile link `https://weibo.com/u/1642909335`, `https://weibo.com/1642909335`, `https://m.weibo.cn/u/1642909335`, `https://weibo.com/n/微博小秘书`, or a screen name `微博小秘书` / `@微博小秘书`. One exact profile row per user (the exact follower integer, not the rounded "1.68亿").

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

Search terms, one per line. A plain word or phrase reads page 1 of each tab in `searchTabs` (about 10–15 posts a tab, about 50 on 图片 pictures); `#topic#` reads the topic page instead. Weibo shows a visitor page 1 only and no date window: the rows say so.

## `searchTabs` (type: `array`):

The search tabs read for each keyword, page 1 each; empty = `all` (综合). A post found in two tabs is one row with both tabs in `search_tabs`. `users` gives `user` rows, `topics` gives up to 10 `hot_item` rows with discussion and read counts, each topic once; the other tabs give `post` rows.

## `maxPostsPerKeyword` (type: `integer`):

The most post rows per keyword over its tabs (0 = every post of the pages read: about 90 over the five post tabs).

## `hotBoards` (type: `array`):

The hot-search boards to read, one `hot_item` row per entry: rank, word, heat, label (新 / 热 / 沸), category, time on board, the pinned topic and promoted entries flagged. With the memory on (`stateStoreName` or `onlyNew`), each row says how it moved since the last run (new, rising, falling, steady) and a row is written for each word that dropped off.

## `postsPerHotTopic` (type: `integer`):

For each ranked word of the realtime board, the top posts of Weibo's 综合 search for it (one search page per word; the pinned topic and promoted entries are skipped; a post two words share is one row, and the second word takes the next post of its page; needs `realtime` in `hotBoards`); 0 = none.

## `hotTimelinePosts` (type: `integer`):

How many posts of Weibo's hot (trending) timeline to deliver, 10 a page; 0 = none. The walk ends when a page adds nothing new (about 100 posts in practice).

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

A search, timeline or hot-timeline row cuts a long post at about 140 characters; with this on, each such post is read in full (one request per long post). Off, the row keeps the cut text and `text_truncated` is true.

## `includeAuthorProfiles` (type: `boolean`):

After the posts, one exact `user` row per distinct author (the exact follower integer; charged as a profile). Every post row already carries the author's name, id, verification and counts as the post page shows them.

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

Comment rows per post row (`comment`: text, time, likes, region, the commenter with exact followers), to the post's own count; 0 = none. Applies to every post row of the run.

## `commentsOrder` (type: `string`):

The order Weibo lists the comments in. Time order reaches more of a big post's comments (98 % of 1,577 in our test); hot order follows Weibo's ranking.

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

Read the replies under each comment that has them (one request per such comment), as `comment` rows with `is_reply` and `parent_comment_id`. Counted in `maxCommentsPerPost`.

## `maxLikersPerPost` (type: `integer`):

Who liked the post, as `user` rows (`list_kind` liker), up to 200 a post (Weibo shows a visitor no more); 0 = none.

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

The newest posts of each user in `users`, as `post` rows; 0 = the profile only. Weibo shows a visitor the newest 10 and no more.

## `maxFollowersPerUser` (type: `integer`):

The user's followers (fans) as `user` rows, 10 a request, with the exact total in `list_total`; 0 = none. Weibo serves a visitor the first few thousand of a big account.

## `maxFollowingPerUser` (type: `integer`):

The accounts the user follows, as `user` rows, 10 a request, to the full count; 0 = none.

## `maxVideosPerUser` (type: `integer`):

The user's video posts as `post` rows (video URL, duration, title); 0 = none.

## `includeUserDetails` (type: `boolean`):

One more request per user in `users`: registration date, credit level and the profile labels, and the birthday, company and school where the user shows them. Weibo shows a visitor no IP location.

## `tagPosts` (type: `boolean`):

Typed tags on every post and comment row from a classification model (Jev, pinned version): `analysis_sentiment` (−1 to 1), `analysis_kind` (news, opinion, promotion, entertainment, personal, complaint, question, other) and the confidence of each. Charged per tagged row.

## `translateTo` (type: `string`):

A language code (`en`, `de`, `ja`, `pt-BR`): a machine translation of each post, comment and hot-board word by an OpenAI model, next to the original (`translation`, with the model named in `translation_note`). Empty = no translation. Charged per translated row.

## `includeRaw` (type: `boolean`):

Keep Weibo's own JSON object on each row (`raw`), for fields this Actor does not name.

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

Deliver only posts no earlier run of the same task delivered (search, topic, timeline, hot-timeline and video rows); turns the memory on. Hot-board rows then carry their change since the last run.

## `stateStoreName` (type: `string`):

Name of the memory between runs. Given, it turns the memory on: hot-board rows get `change_type`, `previous_rank`, `rank_change`, `heat_change` and dropped words get their own rows; with `onlyNew`, posts delivered before are skipped. Empty = derived from the inputs when `onlyNew` is on.

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

The most charged rows this run delivers, all types together. 0 = no limit. Free rows (not found, invalid, empty) do not count.

## `proxyUrl` (type: `string`):

`http://user:pass@host:port` — a proxy of yours to read Weibo through, tried before the Actor's own exits. Leave empty: the Actor brings its own proxies and no Chinese exit is needed.

## `runTag` (type: `string`):

A label copied onto every row (`run_tag`), to tell runs apart in a shared dataset.

## Actor input object example

```json
{
  "posts": [
    "5346699644242007",
    "https://weibo.com/1642909335/RjAS0hNxt"
  ],
  "users": [
    "1642909335",
    "https://weibo.com/u/2803301701",
    "@微博小秘书"
  ],
  "keywords": [
    "亚运会",
    "#热聊亚运会#"
  ],
  "searchTabs": [],
  "maxPostsPerKeyword": 0,
  "hotBoards": [],
  "postsPerHotTopic": 0,
  "hotTimelinePosts": 0,
  "fetchFullText": true,
  "includeAuthorProfiles": false,
  "maxCommentsPerPost": 0,
  "commentsOrder": "time",
  "includeReplies": false,
  "maxLikersPerPost": 0,
  "maxPostsPerUser": 0,
  "maxFollowersPerUser": 0,
  "maxFollowingPerUser": 0,
  "maxVideosPerUser": 0,
  "includeUserDetails": false,
  "tagPosts": false,
  "translateTo": "",
  "includeRaw": false,
  "onlyNew": false,
  "stateStoreName": "",
  "maxItems": 0,
  "runTag": ""
}
```

# Actor output Schema

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

All scraped records in the default dataset. Four row types share one dataset (`row_type` says which): `post`, `user` (an exact profile or a listed user), `comment`, `hot_item`:

## `runSummary` (type: `string`):

How the run went: rows charged per event, free rows by status, posts by region, login walls met, the memory used, and the source counters (requests, exits, bytes, rate walls).

# 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 = {
    "posts": [
        "5346699644242007",
        "https://weibo.com/1642909335/RjAS0hNxt"
    ],
    "users": [
        "1642909335",
        "https://weibo.com/u/2803301701",
        "@微博小秘书"
    ],
    "keywords": [
        "亚运会",
        "#热聊亚运会#"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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 = {
    "posts": [
        "5346699644242007",
        "https://weibo.com/1642909335/RjAS0hNxt",
    ],
    "users": [
        "1642909335",
        "https://weibo.com/u/2803301701",
        "@微博小秘书",
    ],
    "keywords": [
        "亚运会",
        "#热聊亚运会#",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/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 '{
  "posts": [
    "5346699644242007",
    "https://weibo.com/1642909335/RjAS0hNxt"
  ],
  "users": [
    "1642909335",
    "https://weibo.com/u/2803301701",
    "@微博小秘书"
  ],
  "keywords": [
    "亚运会",
    "#热聊亚运会#"
  ]
}' |
apify call hyperbach/weibo-scraper --silent --output-dataset

```

## MCP server setup

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