# Weibo Scraper: Profile Stats & Post Timeline (`themineworks/weibo-scraper`) Actor

Scrape Weibo (China's dominant Twitter-equivalent) by user ID: follower count, verification, bio, and full post timeline with reposts, comments and likes. China residential proxy, no login, no browser.

- **URL**: https://apify.com/themineworks/weibo-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Weibo Scraper: Profile Stats & Post Timeline

> China residential proxy. No login, no browser.

> You are only charged for a profile or post that actually lands in your dataset. Blocked or empty lookups are never billed.

### Overview

Weibo is China's dominant microblogging platform, the closest equivalent to Twitter/X in that market, and it is where Chinese brand mentions, celebrity news, breaking events and public sentiment actually surface first. This actor turns a Weibo user ID into structured rows: the account's public profile stats, and its recent post timeline with repost, comment and like counts on every post.

Give it one or more numeric Weibo user IDs (or full profile URLs that contain one) and it returns:

**Profile info.** Display name, follower and following counts, total post count, verification status and label, bio, avatar.

**Post timeline.** The account's recent posts, each with the post text, publish time, posting client, and its repost/comment/like counts, plus any attached images and whether it carries video or is itself a repost.

✅ Works from any numeric Weibo user ID · ✅ Full engagement stats on every post · ✅ No login, no API key · ✅ MCP-ready for AI agents

### Why this needs a China proxy, and why it still isn't a browser

Weibo blocks non-China IPs at the connection level. A request from outside China does not even complete a TLS handshake with Weibo's servers, so no amount of clever headers ever gets through without a China proxy. That part is unavoidable and this actor is built around it by default.

What is *not* required is a browser. Weibo protects its API behind a "visitor" cookie system: a first-time visitor gets a `432` response until it presents a valid `SUB` cookie, and that cookie is issued by a plain two-step HTTP handshake Weibo's own web client calls before anything else. No JavaScript execution, no canvas fingerprint, nothing a Chromium instance is actually needed for. This actor performs that same two-step handshake as ordinary HTTP requests and then calls Weibo's own JSON API directly, which keeps it an order of magnitude cheaper than a Playwright-based scraper on the same target.

One thing this actor deliberately does **not** do: scrape Weibo search. Weibo's search page now redirects straight to an account sign-in wall even with a valid visitor session, which means real search access needs a logged-in account, and that is out of scope for a public data actor. Profile and timeline data, by contrast, is genuinely public and does not require a login.

### Input

```json
{
  "profileIds": ["1699432410"],
  "maxPostsPerProfile": 10,
  "includeProfileInfo": true
}
```

| Field | What it takes |
| --- | --- |
| `profileIds` | Numeric Weibo user IDs, or full profile URLs that contain one (e.g. `https://weibo.com/u/1699432410`). Find it in the account's own profile URL. Up to 25 per run. |
| `maxPostsPerProfile` | How many recent posts to pull per account. Set to 0 to fetch profile info only, with no timeline. |
| `includeProfileInfo` | Whether to also push a profile-stats row for each account, on top of its posts. |
| `proxyConfiguration` | Defaults to China residential, which is required for this actor to reach Weibo at all. You can supply your own proxy group, but it must still resolve to a China exit node. |

### Output

Two record shapes land in the same dataset, distinguished by `record_type`.

**Profile:**

```json
{
  "record_type": "profile-scraped",
  "uid": 1699432410,
  "screen_name": "example_news_account",
  "verified": true,
  "verified_reason": "Official media account",
  "followers_count": 94210335,
  "following_count": 452,
  "statuses_count": 203466,
  "bio": "Breaking news, as it happens.",
  "profile_url": "https://weibo.com/u/1699432410",
  "scraped_at": "2026-08-14T09:12:03.000Z"
}
```

**Post:**

```json
{
  "record_type": "post-scraped",
  "post_id": "5331585174080569",
  "text": "Breaking: fire department reports one rescuer injured in a factory fire...",
  "published_at": "2026-08-13T14:47:04.000Z",
  "source_client": "Weibo web",
  "reposts_count": 812,
  "comments_count": 340,
  "likes_count": 2110,
  "image_urls": "https://wx1.sinaimg.cn/....jpg",
  "has_video": false,
  "is_repost": false,
  "post_url": "https://m.weibo.cn/status/RdfFPh7xD",
  "scraped_at": "2026-08-14T09:12:07.000Z"
}
```

| Field | Description |
| --- | --- |
| 👤 `screen_name` | Account display name |
| ✅ `verified` / `verified_reason` | Official verification badge and its label text |
| 👥 `followers_count` / `following_count` | Follower and following counts |
| 📝 `statuses_count` | Total posts ever made by the account |
| 💬 `text` | Post text, with all HTML markup stripped |
| 📅 `published_at` | ISO publish timestamp |
| 🔁 `reposts_count` | Repost count |
| 💭 `comments_count` | Comment count |
| ❤️ `likes_count` | Like (attitude) count |
| 🖼️ `image_urls` | Attached images, comma-separated |
| 🎥 `has_video` | Post carries a video attachment |
| 🔄 `is_repost` | This post is itself a repost of another account's post |

### Common use cases

**Brand and PR monitoring.** Track how a brand or spokesperson account is performing on Weibo: follower growth, engagement rate per post, verification status changes.

**Crisis and sentiment tracking.** Pull an official account's timeline (news outlets, regulators, major brands) to see what is being said and how it is landing, in near real time.

**Competitor and influencer research.** Benchmark follower counts, posting cadence and engagement across a shortlist of accounts before a partnership decision.

**Market research into Chinese public discourse.** Weibo is frequently where a story breaks in China before it reaches any Western-facing source. This actor is a structured way to watch specific accounts for that.

**AI agents.** Feed structured Weibo account and post data into an agent tracking Chinese public sentiment on a brand, topic or event.

### Pricing

| Event | Price | You pay when |
| --- | --- | --- |
| Profile scraped | $0.02 | A profile's stats land in your dataset |
| Post scraped | $0.006 | A post from a timeline lands in your dataset |

Blocked or empty lookups cost nothing.

### Run it on a schedule

1. Run once with the profiles you want tracked, then click **Save as a task**.
2. In the Apify Console go to **Schedules → Create new**.
3. Pick a frequency and attach the saved task.
4. Wire the dataset to Sheets, Slack or a webhook from the **Integrations** tab.

Deduplicate on `post_id` so a repeated schedule never reprocesses the same post.

### FAQ

**Do I need a Weibo account?**
No. Everything this actor returns is public profile and post data, reachable without logging in.

**Can this scrape Weibo search results?**
Not currently. Weibo's search now requires an actual account login even for a visitor with a valid session cookie, which this actor deliberately does not attempt. Profile and timeline data does not have that restriction.

**Why does it need a proxy when other actors in this catalog don't?**
Because Weibo blocks non-China traffic at the network level, before any request-level anti-bot logic even runs. It's a firewall rule, not a scraping problem. There is no plain-HTTP path around it, from any country.

**How do I find a user's numeric ID?**
It's in their profile URL: `weibo.com/u/<the number>` or `m.weibo.cn/u/<the number>`.

**Why did I get fewer posts than I asked for?**
Either the account has fewer public posts than your cap, or the timeline API stopped returning a next-page cursor. The run reports what it actually found.

### Use from Claude, ChatGPT and any MCP agent

```
https://mcp.apify.com/?tools=themineworks/weibo-scraper
```

Or call it programmatically:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/weibo-scraper').call({
  profileIds: ['1699432410'],
  maxPostsPerProfile: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Questions, or need a field we don't return yet? Reach out through the Apify profile.

# Actor input Schema

## `profileIds` (type: `array`):

Numeric Weibo user IDs, or full profile URLs that contain one, e.g. https://weibo.com/u/1699432410 or https://m.weibo.cn/u/1699432410. Find the ID in the profile's own URL. Up to 25 per run.

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

How many recent posts to pull from each profile's timeline. About 10 posts per page fetched, so this also controls how many pages are walked.

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

Push one profile-scraped row per user (name, fan count, verification, bio) in addition to their posts.

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

Weibo blocks non-China IPs at the connection level (verified: a request from outside China times out before it even reaches Weibo's application layer). China residential proxy is required, not optional, for this actor to work at all.

## Actor input object example

```json
{
  "profileIds": [
    "1699432410"
  ],
  "maxPostsPerProfile": 5,
  "includeProfileInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CN"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "profileIds": [
        "1699432410"
    ],
    "maxPostsPerProfile": 5,
    "includeProfileInfo": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = {
    "profileIds": ["1699432410"],
    "maxPostsPerProfile": 5,
    "includeProfileInfo": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/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 '{
  "profileIds": [
    "1699432410"
  ],
  "maxPostsPerProfile": 5,
  "includeProfileInfo": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CN"
  }
}' |
apify call themineworks/weibo-scraper --silent --output-dataset

```

## MCP server setup

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