# Weibo Scraper — Posts, Comments, Profiles & Hot Search (`nice_dev/weibo-posts-scraper`) Actor Scrape Weibo (微博) posts by keyword with no page cap and a date range, plus comments, replies, likers, author profiles and hot search lists. No login, no cookie. Export JSON, CSV, Excel. - **URL**: https://apify.com/nice_dev/weibo-posts-scraper.md - **Developed by:** [Nice Dev](https://apify.com/nice_dev) (community) - **Categories:** Social media, Lead generation, MCP servers - **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.63 / 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 ### 🔎 What is Weibo Posts Scraper? **Weibo Posts Scraper** extracts **posts, comments and replies, likers, account profiles, followers and the hot search lists from [Weibo](https://weibo.com)** (微博), China's largest public social network: full text, **likes, comments and reposts**, pictures and videos, topics and mentions, the province it was posted from, and the author's followers and verification — for brand monitoring, market research, opinion tracking or KOL lists in China. Type a **keyword** (`小米`, `#华为#`), add **accounts** or **posts**, or paste any **Weibo URL**, click **Start**, and download the results in JSON, CSV or Excel. No Weibo account, no cookie, nothing to set up — and the keyword search **goes back in time as far as you ask**, not only the first page Weibo shows to visitors. ### 📋 What data can you extract from Weibo? One row per result — a post, a comment, a liker, an account profile, a follower, an account followed or a hot topic — 173 fields: | Category | What you get | | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 📝 **Post** | full text (plain and as Weibo shows it), link, publication date (UTC and Beijing time), edits, the app it was sent from — `握草我的手机刚刚重重一摔…小米牛逼` | | 📊 **Engagement** | likes, comments, reposts and their total, reads when Weibo shows them — `1,204 likes · 87 comments · 35 reposts` | | 📍 **Where it was posted** | province or country as Weibo shows it under the post (发布于 广东), in Chinese and in English, city, place and map position when the post is tied to one | | 🖼️ **Pictures and video** | every full-size picture, the video (best quality and every quality, cover, title, length, plays, orientation), the link or article card | | #️⃣ **Topics and mentions** | #topics#, super topics (超话), mentioned accounts, every link of the text | | 🔁 **Repost and marks** | repost or original, the original post (text, author, counts), promoted post (ad), pinned post, Weibo's label and statements on the post | | 👤 **Author** | name, ID, picture, bio, followers (`2.7万` = 27,000), follows, posts, verification (orange or blue V) and its reason, membership level, badges | | 💬 **Comments (optional)** | text, date, likes, replies, floor, commenter and their region, liked by the post's author, and the replies to each comment | | ❤️ **Likers (optional)** | the accounts that liked a post: name, followers, verification, membership, when they liked it | | 📇 **Contacts (optional)** | e-mails, phone numbers, WeChat / QQ ids, the business-contact line and the agency written in the bio or verification text of the account | | 🌡️ **Sentiment (optional)** | a tone score from -1 (negative) to +1 (positive) and a label (negative, neutral, positive) for each post and each comment or reply, computed on the text already read | | 🪪 **Profile (optional)** | exact follower count, bio, website, verification, account creation date, IP location (IP属地), birthday, credit level, company, school | | 👥 **Followers and following (optional, needs your cookie)** | the accounts that follow an account, and the accounts it follows: the same account columns as the likers, plus the account whose list it is | | 🔥 **Hot lists** | Hot search (热搜), Entertainment (文娱), Life (生活) and Topics (话题榜): rank, title, heat, label 热 / 新 / 沸, category, time on the list, and the change since your previous run | | 🔗 **Where it comes from** | the keyword, hot topic, account or URL that found it, its rank in the results | Every field, with an example, is listed in the **Output** section below. ### ✅ Why use Weibo Posts Scraper? - 🔎 **Deep keyword search**: Weibo shows visitors one page per keyword. This Actor goes back in time page after page — months and years back — as deep as **Max results**, with a date range that starts the search right at the day you ask for. - 🧩 **All of public Weibo in one Actor**: keyword searches, posts by ID or URL, accounts (latest posts, videos, profile), comments and replies, likers, author profiles, the four hot lists and the posts of each hot topic, Weibo's hot feed by channel (财经, 科技, 汽车…) — combined in one run. - 📈 **Hot lists with history**: each run tells you which entries are new on the list, their rank and heat change since your previous run, their best rank and highest heat. - 🎯 **Filters Weibo does not have**: likes, reposts, comments and author followers minimums, verified accounts only, original posts only, pictures or video only, no ads, provinces, excluded words, every word of the keyword. - 🔔 **Monitoring built in**: tick **Only new posts**, schedule the Actor, and each run returns (and charges) only the posts it has never delivered before. Each keyword search stops at the oldest post delivered by the previous run (a run cut short by its maximum cost, its timeout or an abort: the next one also gives the older posts it missed). - 🔐 **No login needed**: no Weibo account, no cookie to hand over. A cookie of your own is optional, to read an account's feed beyond its first 10 posts, or the lists of its followers and of the accounts it follows (see [Weibo cookie (optional)](#weibo-cookie-optional)). - 🔌 API, scheduling, monitoring, integrations (Make, Zapier, n8n, Google Sheets…) and JSON/CSV/Excel export via the Apify platform. ### 🚀 How to scrape Weibo 1. Create a free Apify account. 2. Open **Weibo Posts Scraper** and type a **Search keyword** (e.g. `小米`). 3. Or add **Account IDs**, **Post IDs**, or paste Weibo URLs (a post, an account, a search page) into **Weibo URLs**. 4. Set **Max results** (100 by default, 0 = no limit) — and **Max posts per search** when you run several keywords — then click **Start**. 5. Download the dataset in JSON, CSV, Excel or via API. ### 💰 How much does it cost to scrape Weibo? This Actor uses **pay per event** pricing: a price per post saved, plus a small fee per run start. Comments, likers, account profiles, hot topics, full texts, contacts and sentiment scores are options, off by default, each charged by its own event: leave them unticked to pay for the posts alone. | Apify plan | Post | Comment or reply | Liker | Profile | Hot topic | Full text | Follower | Contact | Sentiment | Post checked by a filter | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | Free | **$0.81** | **$3.59** | **$3.59** | **$0.81** | **$0.45** | **$2.19** | **$1.39** | **$4.49** | **$1.79** | **$0.055** | | Bronze | $0.80 | $3.58 | $3.58 | $0.80 | $0.41 | $2.18 | $1.38 | $3.79 | $1.78 | $0.045 | | Silver | $0.72 | $3.57 | $3.57 | $0.72 | $0.40 | $2.17 | $1.37 | $3.09 | $1.59 | $0.035 | | Gold | $0.63 | $3.56 | $3.56 | $0.63 | $0.39 | $2.16 | $1.19 | $2.29 | $1.39 | $0.025 | Prices per 1,000, plus **$0.01 per run start** ($1 per 100 runs). Platform usage (compute, proxy) is included in the price. Example: 1,000 posts about a brand on the Free plan ≈ $0.82; with the sentiment score of each post ≈ $2.61. - Posts already delivered (**Only new posts**) are not charged again. - **Full text** is charged only for a long post whose full text was read in this run; **Contact** only for a row where at least one contact was found; **Sentiment** only for a post or comment written in Chinese. - **Follower** rows need your own Weibo cookie. - The filters Weibo does not apply itself (dates, likes, reposts, comments and followers minimums, verified, original, media, ads, provinces, excluded words, every word) are checked by the Actor on every post it reads, kept or not: **Post checked by a filter** is charged per post checked. ### ⚙️ Input ```json { "query": "小米", "maxItems": 500 } ``` Several keywords, a cap per keyword, only recent posts, only the ones not delivered before: ```json { "searchQueries": ["小米", "华为", "#新能源汽车#"], "maxItemsPerQuery": 200, "postedAfter": "7 days", "minLikes": 10, "onlyNew": true, "stateKey": "phone-watch" } ``` Posts and accounts, with their comments, likers and profiles: ```json { "postIds": ["5354231135473812"], "userIds": ["1749127163"], "accountData": ["posts", "profile"], "includeComments": true, "includeReplies": true, "includeLikers": true, "maxItems": 100 } ``` The hot search list and the posts of each hot topic: ```json { "includeHotSearch": true, "hotBoards": ["realtime", "entertainment"], "maxHotTopics": 20, "maxPostsPerHotTopic": 30, "maxItems": 600 } ``` The posts of the hot topics count in **Max results** (`maxItems`): set it to at least topics × posts per topic, or the last topics get no post. | Field | Notes | | ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `query`, `searchQueries` | Keyword or phrase, as typed in the Weibo search box (Chinese works best: `小米`; a topic: `#华为#`); `searchQueries` adds more searches (max 100 searches per run, on top of **Search keyword**). | | `sortBy` | `latest` (real-time tab 实时: no depth cap, works with the date range), `hot` (热门) or `top` (综合): Weibo's own ranking, about 10 posts per keyword. | | `matchAllWords` | Keep only the posts that contain every word of the keyword (Weibo also returns posts with only some of them). | | `searchAccounts`, `includeKeywordStats` | For each keyword, also save the accounts Weibo finds for it (the first 20, as **Profile** rows), and its topic row (discussions, reads, participants, as one **Hot topic** row). | | `startUrls` | Weibo URLs: a post (`https://weibo.com//`, `https://m.weibo.cn/detail/`), an account (`https://weibo.com/u/`) or a search page (`https://s.weibo.com/weibo?q=...`). | | `postIds` | Posts by ID: the 16-digit number (`5354231135473812`) or the short code (`RmKNzmXZi`). | | `userIds` | Accounts by numeric ID (`1749127163`) or profile URL. | | `accountData`, `maxPostsPerUser`, `maxVideosPerUser` | What to save for each account: its latest `posts` (10 at most as a visitor: Weibo shows no more; up to 1,000 with your `cookie`) and / or its `profile`; also its video posts (about 20). | | `cookie` | Optional. Your own Weibo cookie (a secret field), to read an account's feed beyond its first 10 posts, or its follower and following lists: see **Weibo cookie (optional)** below. Empty = you read as a visitor. | | `maxFollowersPerUser`, `maxFollowingPerUser` | Off at 0. For each account of `userIds` (or account URL), save up to this many of its followers / of the accounts it follows (5,000 at most each), as **Follower** rows. Needs your `cookie`: the run refuses to start without it. Not tested with a real account yet. | | `hotBoards`, `includeHotSearch`, `maxHotTopics`, `maxPostsPerHotTopic` | The hot lists: `realtime` (热搜, about 50), `entertainment` (文娱, 50), `life` (生活, 50), `topics` (话题榜, paged); how many entries of each, and the latest posts of each entry (0 = entries only). | | `hotChannels`, `includeHotTimeline` | Weibo's hot feed (热门微博): the main feed, or channels by name (`财经`, `科技`, `汽车`; 66 in all) or by ID. | | `includeComments`, `maxCommentsPerPost`, `commentSort` | The comments of each post (20 per page read), the newest first or Weibo's most liked first. 0 = all the comments Weibo shows. | | `includeReplies`, `maxRepliesPerComment` | With the comments: the replies to each comment, marked as replies with their parent comment. | | `includeLikers`, `maxLikersPerPost` | The accounts that liked each post. 0 = all the likers Weibo shows. | | `includeAuthorProfiles` | One **Profile** row for each new post author (exact followers, bio, verification, creation date, IP location, birthday, credit level), each author once per run. | | `includeContacts` | Find e-mails, phone numbers, WeChat / QQ ids and business-contact lines in the account bio and verification text (post authors, profiles, likers, followers, accounts followed); charged as **Contact** per row where at least one is found, no extra request. Off = the six contact fields stay empty. | | `includeSentiment` | Add a tone score (-1 negative … +1 positive) and a label to each post and each comment or reply, computed on the text already read (the full text when `fetchFullText` read it); charged as **Sentiment** per row scored, no extra request. Chinese text only: a text with no Chinese character gets no score and is not charged. Profiles, likers, followers, accounts followed and hot topics get no score. Off = the two sentiment columns stay empty. | | `fetchFullText` | Weibo cuts posts longer than about 140 characters: tick to read the full text of each cut post. Off = the cut text, marked as cut. | | `maxItems`, `maxItemsPerQuery` | Stop after this many posts for the whole run / for each keyword, hot topic or search URL (0 = unlimited). Comments, likers, profiles and hot topics have their own caps. | | `postedAfter`, `postedBefore` | Publication date range, Beijing time: `2026-09-01`, or a period before now (`7 days`, `24 hours`, `2 weeks`). | | `provinces` | Only the posts published from these provinces or regions, in Chinese (`广东`, `北京`) or in English (`Guangdong`, `Beijing`). | | `contentType` | `all`, `pictures`, `videos` or `media` (pictures or video). | | `excludeKeywords` | Drop the posts whose text, reposted text or author name contains one of these words (`抽奖`, `广告`); the full text of a cut post is read for it. | | `originalOnly`, `verifiedOnly`, `excludePromoted` | Original posts only (no repost), verified accounts only (orange or blue V), no promoted posts. | | `minLikes`, `minReposts`, `minComments`, `minFollowers` | Minimum likes, reposts, comments, author followers (`0` = no minimum). | | `stateKey`, `onlyNew`, `resetState` | Monitoring: only the posts never delivered under this memory key (`phone-watch`); `resetState` forgets the memory. | | Advanced: `proxyConfiguration`, `maxConcurrency`, `maxRequestsPerMinute`, `minRequestIntervalMs`, `maxRequestRetries`, `debugLog` | Apify proxy by default, included in the price (the residential proxy is not available); speed, retries and debug messages. | ### 📦 Output A post (shortened: empty fields left out): ```json { "type": "post", "id": "5354311888406436", "url": "https://weibo.com/7223148563/RmMTOzgTG", "foundBy": "search", "searchQuery": "小米", "rank": 2, "scrapedAt": "2026-10-15T07:55:43.449Z", "postId": "5354311888406436", "mid": "5354311888406436", "bid": "RmMTOzgTG", "mobileUrl": "https://m.weibo.cn/detail/5354311888406436", "text": "握草我的手机刚刚重重一摔。。不是摔到地上那么简单。是摔到马桶上然后再到地上。……小米牛逼。[衰][作揖][good]", "textLength": 190, "isLongText": false, "textTruncated": false, "createdAt": "2026-10-15T07:54:55.000Z", "createdAtBeijing": "2026-10-15 15:54:55", "likeCount": 0, "commentCount": 0, "repostCount": 0, "totalInteractions": 0, "region": "河北", "regionEn": "Hebei", "province": "河北", "city": "秦皇岛", "country": "中国", "imageCount": 0, "isRepost": false, "isPromoted": false, "isPinned": false, "authorId": "7223148563", "authorName": "wawjknnnnnn", "authorUrl": "https://weibo.com/u/7223148563", "authorVerified": false, "authorVerifiedType": -1, "authorFollowersCount": 11, "authorFollowersText": "11", "authorFollowingCount": 137, "authorPostsCount": 1616, "authorGender": "f", "authorMemberRank": 2, "searchUrl": "https://s.weibo.com/realtime?q=%E5%B0%8F%E7%B1%B3", "authorUserRank": 4 } ``` You can download the dataset in various formats such as JSON, HTML, CSV or Excel. The dataset has five views — Overview, Comments, Profiles and likers, Followers and following, Hot search — each with the columns of its kind of row. #### All 173 fields | Fields | What you get | | --- | --- | | `type`, `id`, `url`, `foundBy`, `searchQuery`, `searchUrl`, `rank`, `scrapedAt` | **Result**: `post`, `comment`, `liker`, `profile`, `follower`, `following` or `hotTopic`; its Weibo ID, its weibo.com page; how it was reached (`search`, `hotTopic`, `hotTimeline`, `account`, `post`, `url`), the keyword or hot topic and its search page, the rank in the results or on the list, ISO timestamp | | `postId`, `mid`, `bid`, `mobileUrl` | **Post IDs**: the 16-digit post ID (also on comment and liker rows), the short code of weibo.com links, the m.weibo.cn page | | `text`, `textHtml`, `textLength`, `isLongText`, `textTruncated`, `contentStatements` | **Text**: plain text (line breaks, #topics# and @mentions kept), the text as Weibo returns it (links, emoticon pictures), its length, cut by Weibo or not, cut in this row or not, statements Weibo shows on the post | | `createdAt`, `createdAtBeijing`, `editedAt`, `editCount` | **Dates**: publication (ISO UTC, and `YYYY-MM-DD HH:mm:ss` Beijing time), last edit and number of edits | | `likeCount`, `commentCount`, `repostCount`, `totalInteractions`, `readCount` | **Engagement** at scrape time; the total = likes + comments + reposts; reads when Weibo shows them | | `source`, `region`, `regionEn`, `province`, `city`, `country`, `latitude`, `longitude`, `placeName` | **Where**: the app it was sent from (`iPhone客户端`), the region Weibo shows under the post (commenter's region on a comment) and in English, province, city, country, the place the post is tied to and its position | | `images`, `imageCount`, `picIds` | **Pictures**: full-size URLs, their number, their Weibo IDs | | `videoUrl`, `videoStreams`, `videoCoverUrl`, `videoTitle`, `videoDurationSeconds`, `videoPlayCount`, `videoPageUrl`, `videoOrientation` | **Video**: best-quality mp4 (a link that expires about an hour after the run) and every quality, cover, title, length in seconds, plays, its durable weibo.com page, `horizontal` or `vertical` | | `linkUrl`, `linkTitle`, `linkType`, `linkSummary` | **Card** attached to the post (article, web page, video, topic): URL, title, kind, summary | | `topics`, `superTopics`, `topicId`, `mentions`, `links` | #topics# (without #), super topics (超话), the main topic page, @mentioned accounts (without @), URLs of the text | | `isRepost`, `repostOf`, `originalPostId`, `isPromoted`, `isPinned`, `contentLabel` | **Repost and marks**: repost or not, the original post (ID, link, text, date, author, counts), its ID; promoted post (ad), pinned on its author's page, Weibo's label (`热门`) | | `authorId`, `authorName`, `authorUrl`, `authorAvatarUrl`, `authorDescription`, `authorGender` | **Author** of the post or comment: ID, name, page, picture, bio, gender as declared | | `authorVerified`, `authorVerifiedType`, `authorVerifiedReason`, `authorBadges` | verified (V) or not; -1 none, 0 person (orange V), 1-7 organisation (blue V), 220+ personality; the text of the verification; the badges next to the name | | `authorFollowersCount`, `authorFollowersText`, `authorFollowingCount`, `authorPostsCount`, `authorTotalInteractions` | followers (from Weibo's rounded display: `2.7万` = 27,000; exact on Profile rows) and the display itself, follows, posts, likes + comments + reposts received | | `authorMemberRank`, `authorUserRank`, `authorIsSvip`, `authorMemberType`, `authorIsVvip`, `authorIsVplus` | membership level, user level, SVIP, membership kind, VVIP, V+ | | `commentId`, `parentCommentId`, `rootCommentId`, `isReply`, `replyToUserName`, `replyToUserId`, `replyCount`, `floorNumber`, `isLikedByAuthor` | **Comment**: its ID, the comment a reply answers and the first one of the thread, reply or not, the account answered, replies, floor under the post, liked by the post's author | | `userId`, `screenName`, `userUrl`, `avatarUrl`, `description`, `gender`, `weihao`, `customDomain`, `website` | **Account** (liker, profile, follower and following rows): ID, name, page, picture, bio, gender, Weibo number (微号), personal address, website | | `contactEmails`, `contactPhones`, `contactWechat`, `contactQq`, `businessContact`, `agency` | **Contacts** (option `includeContacts`, empty otherwise; post, profile, liker, follower and following rows): e-mails (obscured forms like `name(at)163.com` read), phones (Chinese mobiles as `+86` + 11 digits, landlines like `010-12345678`, international `+…`), WeChat ids, QQ numbers, the line of the bio that gives a business contact, the agency / MCN named; nothing found = `[]` / `null` | | `sentimentScore`, `sentimentLabel` | **Sentiment** (option `includeSentiment`, `null` otherwise; post and comment rows): the tone of the text from -1 (negative) to +1 (positive), 3 decimals, and its label `negative` / `neutral` / `positive`; a text with no Chinese character has no score (`null`) | | `verified`, `verifiedType`, `verifiedTypeExt`, `verifiedReason`, `badges` | verification, its type (same codes as the author's), its extra level (1 = gold V), its text, the badges next to the name | | `followersCount`, `followersText`, `followingCount`, `postsCount`, `totalLikes`, `totalComments`, `totalReposts`, `totalInteractionsText`, `favoritesCount`, `videoCount`, `videoPlaysTotal`, `mutualFollowCount`, `followingPagesCount` | followers (exact on Profile rows) and as displayed, follows, posts, likes, comments and reposts received by all its posts, their total as displayed, favourites, videos and their plays, mutual follows, pages followed | | `memberRank`, `isSvip`, `memberType`, `isVvip`, `isVplus`, `memberExpiresAt` | membership level, SVIP, membership kind, VVIP, V+, end of the paid membership | | `location`, `ipLocation`, `birthday`, `registeredAt`, `sunshineCredit`, `company`, `school`, `profileLabels`, `coverImageUrl` | **Profile**: location written on it, IP location (IP属地), birthday or star sign, account creation date, credit level, company and school when public, activity lines (`昨日发博56`), cover picture | | `likedAt` | **Liker**: when the account liked the post (ISO UTC when Weibo gives the time) | | `ofUserId`, `ofUserName`, `fanUid` | **Follower / Following**: the account whose list the row comes from (its ID and its name), and the ID of the listed account (the same as `userId`). The `id` of the row is `follower::` or `following::`: the same account in two lists is two rows | | `title`, `heat`, `label`, `category`, `isAd`, `onboardAt`, `minutesOnBoard`, `isTopic`, `board`, `isGovernmentTopic`, `leadPostUrl`, `starNames` | **Hot topic**: the entry, its heat, label 热 / 新 / 沸 / 爆, category, promoted entry, when it entered the list and minutes since, topic page or plain word, which list (`realtime`, `entertainment`, `life`, `topics`), pinned by Weibo at the top, its lead post, the celebrities linked to it | | `isNew`, `firstSeenAt`, `previousRank`, `rankChange`, `peakRank`, `previousHeat`, `heatChange`, `peakHeat` | **Hot list history** (same **Memory key**): new since the previous run, first seen, previous rank and change (positive = climbing), best rank, previous heat and change, highest heat | | `discussCount`, `summary`, `imageUrl`, `topicReadCount`, `topicHostId`, `topicHostName`, `keywordParticipants` | **Topic** (Topics list and **Keyword stats**): discussions, summary, picture, reads, the account hosting the topic page, people taking part in the keyword's conversation | ### 💡 Tips #### How to get more results Leave **Search tab** on `latest` and raise **Max results**: the search goes back in time page after page, with no cap of one page. Set **Posted before** to start right at an older date. Combine keywords, accounts, posts and hot lists in one run, and set **Max posts per search** so that one big keyword does not use up the whole budget. #### How to reduce costs The price is per post saved, so the levers are **Max results**, **Max posts per search**, the filters (a filtered-out post costs only its small filter fee) and **Only new posts** for recurring runs (you never pay twice for the same post). Comments, likers, profiles, followers, hot topics and full texts are charged per row or per post completed: leave them off when you need the posts alone, and cap them with their own caps (**Comments per post**, **Likers per post**, **Followers per account**…). The date range also makes the keyword search start at **Posted before** and stop at **Posted after**: the posts outside it are mostly never read, so never charged. #### Several searches in one run Fill **More search keywords** (max 100 searches per run, on top of **Search keyword**), **Account IDs**, **Post IDs** and **Weibo URLs**: each keyword, account, post and URL is a source of its own. A post found by several sources is saved — and charged — once. #### Monitoring: only the new posts Tick **Only new posts** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips the posts already delivered: they are not saved and not charged, and their comments and likers are not read again. The memory lives in a named key-value store of your account (`weibo-posts-scraper-seen`, up to 150,000 posts per key) and is only updated with posts that really reached the dataset, so a failed run never hides anything. Give each schedule its own **Memory key** (two schedules sharing a key would hide each other's posts), and tick **Reset the memory** once to start over. Hot topics are not filtered: every run gives the current list, with what changed since the previous run. A profile row already delivered under the same key is not given again; so is a follower or following row (the same account in the same list of the same account), which makes the Actor a way to watch for new followers. The memory holds up to 150,000 ids per key, posts, profiles and followers together: give a list-heavy schedule its own **Memory key**. #### Weibo cookie (optional) Weibo shows visitors the 10 latest posts of an account, and shows the lists of its followers and of the accounts it follows to signed-in users only. To read more of an account's feed (**Posts per account** above 10, up to 1,000), or these two lists (**Followers per account** and **Following per account**, up to 5,000 each, charged as **Follower** rows, off at 0), give the cookie of your own Weibo account in **Your Weibo cookie (optional)**; leave it empty and everything else works as before. A list asked for without a cookie is refused before the run starts. How to copy it: 1. Log in to weibo.com in your browser. 2. Open the developer tools (F12), then the **Network** tab, and reload the page. 3. Click any request to weibo.com, find the `Cookie` request header and copy its whole value. It must contain `SUB=`. 4. Paste it in the field. It is a secret field: Apify hides it. Your account is used for the next pages of the account feeds and for the follower and following lists only, and for nothing else; we never store or log it. If Weibo refuses the cookie or it has expired, the Actor stops reading that feed or that list at once, keeps the rows it already saved and says "Your Weibo cookie was refused or expired" in the last line of the log: copy a fresh cookie and run it again. Rows that were not read are not charged. Use an account of your own: Weibo may ask it to log in again after heavy use. Not tested with a real account yet, neither the feed pages nor the follower and following lists: the Actor reads the lists the way Weibo shows them to a signed-in user, but we have not seen a real answer. If something fails, tell us in the Issues tab. #### Filter by publication date **Posted after** and **Posted before** take a date (`2026-09-01`, the whole day is included, Beijing time) or a period before now (`7 days`, `2 weeks`, `1 month`). The keyword search stops as soon as it reaches posts older than **Posted after**, and starts directly at **Posted before**. Comments, likers, profiles and hot topics are not filtered by date. Each post the date filter checks, kept or not, is charged the small filter fee. ### 🔌 Integrations and API Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtable…). The dataset can be fetched as JSON or CSV from any tool. ### 🤖 Use with AI agents (MCP) AI agents (Claude, ChatGPT, Cursor…) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one row per Weibo result: a post, a comment, a liker, an account profile, a follower, an account followed or a hot topic (`type` says which). Actor id: `nice_dev/weibo-posts-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/weibo-posts-scraper`. Smallest input, for a cheap first call: ```json { "query": "小米", "maxItems": 10 } ``` Key output fields: `type`, `url`, `text`, `createdAt`, `likeCount`, `commentCount`, `repostCount`, `authorName`, `region`. Cost: a price per post saved plus a small fee per run start; the Actor's own filters and the options (comments, likers, profiles, followers, hot topics, full text; all off by default) cost extra, see the pricing section above. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`. ### ❓ FAQ #### Is it legal to scrape Weibo? The Actor only reads what Weibo shows publicly to any visitor, without an account. It logs in to nothing by itself: the optional cookie is yours, used only for your own run. Results contain personal data (names, bios, posts, comments, the region a post was sent from, e-mail addresses people wrote in their bio), which is protected by China's Personal Information Protection Law (PIPL), by GDPR and by similar laws: do not store it without a legitimate reason, and delete what an author has deleted. You are responsible for using the data in compliance with Weibo's Terms of Service and applicable law. This Actor is not affiliated with Weibo or Sina. #### Does it need a Weibo account or a proxy? No account is needed, and no cookie unless you want an account's feed beyond its first 10 posts, or the lists of its followers and of the accounts it follows (see **Weibo cookie (optional)**). The proxy is included in the price: leave the default setting (the residential proxy is not available). A request Weibo turns away is retried at once with a fresh visitor session and proxy, up to 10 times on top of the retries (without a proxy, after a pause of 5 seconds, doubled at each retry up to 150 seconds). #### Is the data safe to open in Excel or to show on a web page? Posts, comments and bios are their authors' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@` (a mention, `-20% today`): Excel and Google Sheets may read such a cell of a CSV file as a formula. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. `textHtml` is the post as Weibo returns it, with its links and pictures: the Actor does not sanitize it. On a web page, escape every field like any text written by a stranger. #### Known limitations Weibo shows some pages to logged-in users only, and this Actor logs in to nothing but your own cookie, when you give one: - **Hot** and **Top** searches give about 10 posts per keyword; **Latest** has no such cap. - An account gives its 10 latest posts (and about 20 videos). For more, give your own Weibo cookie (see **Weibo cookie (optional)**), or search its name or a keyword with a date range. - **Matching accounts** gives the first 20 accounts per keyword. - The list of reposts of a post is not available. The followers of an account and the accounts it follows are read with your own cookie only (see **Weibo cookie (optional)**), up to 5,000 of each per account. - Comments, replies and likers: as many as Weibo shows without login, which can be fewer than the counts on the post. Other limitations: - A video link (`videoUrl`) expires about an hour after the run: download it right away, or keep `videoPageUrl`. - `onlyNew` remembers post IDs, not their content: a post whose likes changed is not returned again. - Two runs sharing the same **Memory key** at the same time may both return the same new post. **A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with `onlyNew`, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options). **A run the platform stops without warning** (out of memory) - Resurrect it: it goes on from where it stood at most a minute before the stop. The posts already saved are skipped: none is delivered or charged twice, and **Max results** still counts them. - With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the posts it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the posts of its last 2 seconds once more. #### Something doesn't work? The last line of the log counts the results saved, filtered out, not found on Weibo (a post or account deleted or hidden), the sources skipped because Weibo shows them only to logged-in users (or because the cookie you gave was refused), and the requests that failed after every retry. Those requests and the posts not found are listed, with the reason, in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause. If Weibo changes its answers, you are told instead of paying for blank rows. If the first 20 posts read all lack their publication date, text or author, the run saves nothing more, stops and fails, and its last message names the missing field: at most those first posts are charged. A run of fewer posts (a scheduled `onlyNew` run that finds a few new ones, a small **Max results**) is checked at its end, from 5 posts: its posts are already saved, and the run fails with the missing field instead of ending green. ### 🛟 Support Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly what failed and why. # Actor input Schema ## `query` (type: `string`): Word or phrase, as typed in the Weibo search box (Chinese works best, e.g. `小米`; a `#topic#` searches that topic). ## `searchQueries` (type: `array`): Several keywords in one run: one search per keyword. Added to **Search keyword**; a post found by several searches is saved once. ## `sortBy` (type: `string`): **Latest** = Weibo's real-time tab (实时), no depth cap, works with the date range. **Hot** (热门) and **Top** (综合) = Weibo's own ranking, about 10 posts per keyword (Weibo shows more only to logged-in users). ## `matchAllWords` (type: `boolean`): Keep only posts that contain every word of the keyword (checked on the post text, the reposted text, the author name and the card title). The full long text of cut posts is read for this check, even when "Full long text" is off. Weibo's search also returns posts with only some of the words. Each post checked, kept or not, is charged the filter fee. ## `searchAccounts` (type: `boolean`): For every keyword, also save the accounts Weibo finds for it (用户 tab, the first 20; Weibo shows more only to logged-in users), as **Profile** rows. Charged as **Profile**. ## `includeKeywordStats` (type: `boolean`): For every keyword, also save its topic row (话题: discussions, reads, summary) and the number of participants, as one **Hot topic** row. 2 extra requests per keyword. Charged as **Hot topic**. ## `startUrls` (type: `array`): Post URLs (`https://weibo.com//`, `https://m.weibo.cn/detail/`, `https://m.weibo.cn/status/`), account URLs (`https://weibo.com/u/`, `https://m.weibo.cn/u/`, `https://weibo.com/`) or search URLs (`https://s.weibo.com/weibo?q=...`, `https://m.weibo.cn/search?containerid=...`: the keyword is read from it). Max 1 000 URLs. ## `postIds` (type: `array`): Posts by ID: the 16-digit number (`mid`, e.g. `5354231135473812`) or the short code (`bid`, e.g. `RmKNzmXZi`). One row per post, with comments / likers if ticked below. ## `userIds` (type: `array`): Accounts by numeric ID (`uid`, e.g. `1749127163`) or profile URL. See **Account data** for what is saved. ## `accountData` (type: `array`): For each account (Account IDs, account URLs): its **latest posts** (Weibo shows the 10 most recent without login; more with your Weibo cookie) and / or its **profile** (exact follower count, bio, verification, account creation date, IP location, birthday, credit level; charged as **Profile**). ## `maxPostsPerUser` (type: `integer`): Cap on the latest posts saved per account. Weibo shows at most 10 to visitors; to go above 10 (up to 1 000), give your Weibo cookie below. ## `maxVideosPerUser` (type: `integer`): Also save the video posts of each account (video tab, about 20; Weibo shows more only to logged-in users), as **Post** rows. 0 = none. ## `cookie` (type: `string`): Leave empty and everything works as a visitor. Give the cookie of YOUR Weibo account to read an account's feed beyond its first 10 posts (**Posts per account** above 10) or its follower and following lists (**Followers per account**, **Following per account** below): Weibo shows these only to logged-in users. How to copy it: log in to weibo.com in your browser, open the developer tools (F12) › Network, click any request to weibo.com and copy the whole `Cookie` request header; it must contain `SUB=`. A `SUB=...` value alone also works. Your account is used for these requests only; we never store or log it. Not tested with a real account yet: tell us in the Issues tab if something fails. Use an account of your own: Weibo may ask it to log in again after heavy use. ## `maxFollowersPerUser` (type: `integer`): Save the followers of each account above (and of each account URL): one **Follower** row each (name, ID, followers, verification, bio fields Weibo shows in lists), newest first as Weibo lists them. Needs your Weibo cookie (see **Your Weibo cookie**): the run refuses to start without it. Charged as **Follower**, only when this is above 0. 0 = off. Not tested with a real account yet. ## `maxFollowingPerUser` (type: `integer`): Save the accounts each account above (and each account URL) follows: one **Follower** row each, marked `following` in **Type**. Needs your Weibo cookie (see **Your Weibo cookie**): the run refuses to start without it. Charged as **Follower**, only when this is above 0. 0 = off. Not tested with a real account yet. ## `includeHotSearch` (type: `boolean`): Save the current hot lists chosen below: one **Hot topic** row per entry (rank, title, heat, label 热 / 新 / 沸, category, time on the list, and the change since the previous run with the same **Memory key**). Charged as **Hot topic**. ## `hotBoards` (type: `array`): Which lists to read: **Hot search** (热搜, about 50), **Entertainment** (文娱, 50), **Life** (生活, 50), **Topics** (话题榜: topic pages ranked, with reads, discussions and summary; paged). ## `maxPostsPerHotTopic` (type: `integer`): With **Hot search list**: also search the posts of each hot topic (latest first), up to N per topic. 0 = topics only. ## `maxHotTopics` (type: `integer`): How many entries of each hot list to keep, from the top (Hot search, Entertainment and Life have about 50; Topics is paged). ## `includeHotTimeline` (type: `boolean`): Also save the posts of Weibo's hot feed (热门微博, the trending posts of the day), up to **Max results**. ## `hotChannels` (type: `array`): With **Hot posts feed**: which channels of the feed to read, by name (`财经`, `科技`, `汽车`, `体育`, `数码`, `房产`, `国际`, `游戏`…, 66 in all) or by channel ID (`group_id`). Empty = the main hot feed only. ## `includeComments` (type: `boolean`): Save the comments of each post: one **Comment** row each (text, date, likes, reply count, floor, region of the commenter, commenter's name, ID and verification). Charged as **Comment**. ## `maxCommentsPerPost` (type: `integer`): Cap on the comments saved per post (20 per page read). 0 = all comments Weibo shows. ## `commentSort` (type: `string`): **Latest** = newest comments first. **Hot** = Weibo's most liked comments first. ## `includeReplies` (type: `boolean`): With **Comments**: also save the replies to each comment, as **Comment** rows marked `isReply` with their parent comment ID. ## `maxRepliesPerComment` (type: `integer`): Cap on the replies saved per comment. 0 = all replies. ## `includeLikers` (type: `boolean`): Save the accounts that liked each post: one **Liker** row each (name, ID, followers, verification, liked when). Charged as **Liker**. ## `maxLikersPerPost` (type: `integer`): Cap on the likers saved per post. 0 = all likers Weibo shows. ## `includeAuthorProfiles` (type: `boolean`): Add one **Profile** row for each new post author (exact follower count, bio, verification, account creation date, IP location, birthday, credit level; 2 extra requests per author, each author once per run). Charged as **Profile**. ## `includeContacts` (type: `boolean`): Find e-mails, phone numbers, WeChat / QQ ids and business-contact lines in the account bio and verification text of post authors, profiles, likers, followers and accounts followed; charged per row where at least one is found. Charged as **Contact**. No extra request. Off = the six contact fields stay empty. ## `includeSentiment` (type: `boolean`): Add a tone score of each post and each comment or reply, from -1 (negative) to +1 (positive), and a label (negative, neutral, positive). Computed on the text already read, no extra request; with the full long text option, on the full text. Chinese text only: a text with no Chinese character gets no score and is not charged. Charged as **Sentiment** per row scored. Profiles, likers, followers and hot topics get no score. Off = the two sentiment columns stay empty. ## `fetchFullText` (type: `boolean`): Weibo cuts posts longer than about 140 characters (`isLongText`). Tick to read the full text of each cut post (1 extra request per cut post). Charged as **Full text** per post completed. Off = the cut text, marked `textTruncated`. ## `maxItems` (type: `integer`): Maximum number of posts saved for the whole run (after deduplication and filters). Comments, likers, profiles and hot topics have their own caps above. 0 = no limit. ## `maxItemsPerQuery` (type: `integer`): Cap for EACH keyword, hot topic or search URL, so that the first search cannot use up the whole **Max results** budget. 0 = no per-search cap. ## `postedAfter` (type: `string`): Only posts published on or after this date, Beijing time (UTC+8): `2026-09-01`, or a period before now such as `7 days`, `24 hours`, `2 weeks`. Reads the post's publication date. The keyword search stops as soon as it reaches older posts. ## `postedBefore` (type: `string`): Only posts published on or before this date, Beijing time (the whole day is included), or older than a period such as `30 days`. The keyword search starts directly at this date (it does not read the newer posts). ## `excludeKeywords` (type: `array`): Drop the posts whose text, reposted text or author name contains one of these words (case ignored). The full long text of cut posts is read for this check, even when "Full long text" is off. ## `originalOnly` (type: `boolean`): Drop reposts (转发): keep only posts written by their author. ## `contentType` (type: `string`): Keep only the posts with pictures, with a video, or with either. ## `verifiedOnly` (type: `boolean`): Keep only posts by verified accounts (orange or blue V: people, media, brands, institutions). ## `excludePromoted` (type: `boolean`): Drop the promoted posts (ads) Weibo mixes into the results. ## `minLikes` (type: `integer`): Keep only posts with at least this many likes. 0 = no minimum. ## `minReposts` (type: `integer`): Keep only posts with at least this many reposts. 0 = no minimum. ## `minComments` (type: `integer`): Keep only posts with at least this many comments. 0 = no minimum. ## `minFollowers` (type: `integer`): Keep only posts whose author has at least this many followers (as shown on the post: `2.7万` = 27 000). 0 = no minimum. ## `provinces` (type: `array`): Keep only posts published from these provinces or regions, as Weibo shows them under the post (`发布于 广东`): Chinese (`广东`, `北京`) or English (`Guangdong`, `Beijing`). Posts without a region are dropped. ## `onlyNew` (type: `boolean`): Skip the posts that a previous run (same **Memory key**) already delivered: they are not saved and not charged, and their comments / likers are not read again. Each keyword search stops at the oldest post delivered by the previous run (after a run cut short by its maximum cost, its timeout or an abort, the older posts it missed are given too). First run = everything is new. ## `stateKey` (type: `string`): Name of the memory used by **Only new posts**. Give each schedule / task its own key (e.g. `xiaomi-watch`) so that they do not share their memory. Letters, digits, `-` and `_`. ## `resetState` (type: `boolean`): Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every post again. Untick it afterwards. ## `proxyConfiguration` (type: `object`): Apify Proxy or your own proxies. Keep the default Apify proxy: it is included in the price. The residential Apify proxy is not available in this Actor. ## `maxConcurrency` (type: `integer`): Maximum number of requests processed in parallel. ## `maxRequestsPerMinute` (type: `integer`): Most requests to Weibo in any 60 seconds, all of them counted (search, comments, likers, profiles, long text). Lower it if the log shows HTTP 418 / 429 (Weibo's rate limit). ## `minRequestIntervalMs` (type: `integer`): Smallest gap between two requests, in milliseconds. Unlike the per-minute rate, this spreads the requests evenly instead of letting them go out in a burst. 0 = no gap. ## `maxRequestRetries` (type: `integer`): Retries per request before it is marked as failed. A request Weibo turns away (418 / 429, visitor page) is retried with a fresh visitor session and proxy up to 10 times without using up these retries. ## `debugLog` (type: `boolean`): Include debug messages in the run log. ## Actor input object example ```json { "query": "小米", "searchQueries": [], "sortBy": "latest", "matchAllWords": false, "searchAccounts": false, "includeKeywordStats": false, "startUrls": [], "postIds": [], "userIds": [], "accountData": [ "posts" ], "maxPostsPerUser": 10, "maxVideosPerUser": 0, "maxFollowersPerUser": 0, "maxFollowingPerUser": 0, "includeHotSearch": false, "hotBoards": [ "realtime" ], "maxPostsPerHotTopic": 0, "maxHotTopics": 50, "includeHotTimeline": false, "hotChannels": [], "includeComments": false, "maxCommentsPerPost": 50, "commentSort": "hot", "includeReplies": false, "maxRepliesPerComment": 20, "includeLikers": false, "maxLikersPerPost": 50, "includeAuthorProfiles": false, "includeContacts": false, "includeSentiment": false, "fetchFullText": false, "maxItems": 100, "maxItemsPerQuery": 0, "excludeKeywords": [], "originalOnly": false, "contentType": "all", "verifiedOnly": false, "excludePromoted": false, "minLikes": 0, "minReposts": 0, "minComments": 0, "minFollowers": 0, "provinces": [], "onlyNew": false, "stateKey": "default", "resetState": false, "proxyConfiguration": { "useApifyProxy": true }, "maxConcurrency": 4, "maxRequestsPerMinute": 120, "minRequestIntervalMs": 0, "maxRequestRetries": 5, "debugLog": false } ``` # Actor output Schema ## `results` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "query": "小米", "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("nice_dev/weibo-posts-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "query": "小米", "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("nice_dev/weibo-posts-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 '{ "query": "小米", "proxyConfiguration": { "useApifyProxy": true } }' | apify call nice_dev/weibo-posts-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/weibo-posts-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 ` 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/BvOQAhM811LLqkbVs/builds/y9t2cGecvPCH4Qdn5/openapi.json