# Weibo Posts and Profiles Scraper (`automation-lab/weibo-posts-profiles-scraper`) Actor

Collect public Weibo posts, media links, engagement counts, and profile metadata from supplied UIDs for repeatable Chinese social intelligence.

- **URL**: https://apify.com/automation-lab/weibo-posts-profiles-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Posts and Profiles Scraper

Collect recent public Weibo posts and public profile metadata from supplied numeric UIDs or profile URLs. The Actor returns clean post text, media links, timestamps, authors, engagement counts, follower signals, and verification details for scheduled Chinese social intelligence.

Teams researching **weibo gaming**, major publishers, brands, creators, or public discussion can turn a stable list of profiles into run-scoped JSON, CSV, Excel, or API datasets without supplying a Weibo login.

### What does Weibo Posts and Profiles Scraper do?

The Actor accepts up to 20 Weibo UIDs or public profile URLs in one run.

It can:

- collect recent public posts from each supplied profile;
- extract full post text when Weibo exposes a public long-text response;
- save public image and video links without downloading heavy media;
- return repost, comment, and like counts;
- collect profile biography, audience size, post count, verification, and public media;
- separate posts and profiles into two run-scoped datasets;
- stop at per-profile and global post limits;
- run repeatedly on an Apify schedule for change tracking.

The primary `default` dataset contains posts. The `profiles` dataset alias contains profile records, so each entity type has its own schema and export.

### Who is this Weibo data scraper for?

- Brand intelligence teams monitoring public Chinese social channels.
- Gaming and entertainment analysts following official publishers and creators.
- Market researchers comparing public audience and engagement signals.
- Newsrooms and academics building bounded public-post datasets.
- Data engineers sending recurring Weibo exports to a warehouse.
- NLP teams preparing public Chinese-language text for classification or sentiment analysis.

### Why use this Actor?

A UID-based workflow is repeatable: the same profile list can run daily or weekly without depending on a broad search result page.

The Actor uses one bounded anonymous browser session to establish Weibo's public visitor state, then reads structured mobile JSON responses. Images, video payloads, and fonts are blocked during browser bootstrap to reduce runtime and memory.

It does not accept account passwords, private cookies, or private-profile access. It also does not silently switch to a paid residential proxy.

### Supported Weibo inputs and scope

Supported values in `uids`:

- a numeric UID such as `2803301701`;
- `https://weibo.com/u/2803301701`;
- `https://m.weibo.cn/u/2803301701`.

Supported output modes:

- `postsAndProfiles` — recent posts in the default dataset and one profile row per resolved UID in `profiles`;
- `postsOnly` — recent posts in the default dataset;
- `profilesOnly` — public metadata in the `profiles` dataset with no timeline requests.

The Actor does not support keyword search, comments, follower lists, private posts, deleted posts, or login-only content.

### Getting started

1. Open the Actor input form.
2. Add one or more numeric UIDs or public profile URLs.
3. Choose an output mode.
4. Set a small `maxPostsPerProfile` for the first run.
5. Set `maxItems` to cap total post rows.
6. Start the run.
7. Open **Posts** for the default dataset or **Profiles** for profile metadata.
8. Export the relevant dataset as JSON, CSV, Excel, XML, or JSONL.

### Example: collect posts and profile metadata

```json
{
  "uids": ["2803301701"],
  "mode": "postsAndProfiles",
  "maxPostsPerProfile": 10,
  "maxItems": 10
}
```

This produces up to 10 post records and one profile record.

### Example: monitor several public publishers

```json
{
  "uids": ["2803301701", "1699432410"],
  "mode": "postsAndProfiles",
  "maxPostsPerProfile": 20,
  "maxItems": 40
}
```

Save this input as an Apify Task and schedule it daily or weekly. Compare `postId`, engagement fields, and `scrapedAt` in your downstream system to identify new records or changed public counts.

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `uids` | string array | `['2803301701']` | One to 20 numeric UIDs or supported public profile URLs. |
| `mode` | string | `postsAndProfiles` | Select posts and profiles, posts only, or profiles only. |
| `maxPostsPerProfile` | integer | `10` | Recent posts to save per profile, from 1 to 100. |
| `maxItems` | integer | `100` | Global post limit across all UIDs, from 1 to 1,000. Profile rows do not consume this limit. |

Duplicate UIDs are removed before collection. Unsupported domains, malformed URLs, and non-numeric identifiers fail input validation instead of being guessed.

### Post output fields

| Field | Meaning |
| --- | --- |
| `postId` | Stable numeric Weibo post identifier. |
| `bid` | Short identifier used in public status URLs. |
| `url` | Canonical mobile status URL. |
| `uid` | Numeric UID of the visible author. |
| `authorName` | Public profile display name. |
| `authorProfileUrl` | Public mobile profile URL. |
| `text` | Plain post text with markup removed. |
| `createdAt` | Timestamp returned by Weibo. |
| `source` | Public client/source label. |
| `region` | Public posting region when available. |
| `repostsCount` | Public repost count. |
| `commentsCount` | Public comment count. |
| `likesCount` | Public like count. |
| `imageUrls` | Public image links attached to the post. |
| `videoUrl` | Public media link when exposed. |
| `isRepost` | Whether the post contains a reposted status. |
| `originalPostId` | Original status identifier when available. |
| `scrapedAt` | ISO timestamp for this collection run. |

Unavailable optional fields are returned as `null` or an empty array according to the dataset schema.

### Profile output fields

| Field | Meaning |
| --- | --- |
| `uid` | Numeric Weibo profile identifier. |
| `screenName` | Public display name. |
| `profileUrl` | Canonical mobile profile URL. |
| `description` | Public biography. |
| `avatarUrl` | Public avatar URL. |
| `coverImageUrl` | Public profile cover URL. |
| `followersCount` | Approximate numeric audience size, converting displayed 万 and 亿 units. |
| `followersCountText` | Audience size exactly as Weibo displays it. |
| `followingCount` | Public following count. |
| `postsCount` | Public total post count when exposed. |
| `verified` | Public verification flag. |
| `verifiedReason` | Public verification description. |
| `gender` | Public gender code when exposed. |
| `location` | Public profile location when exposed. |
| `scrapedAt` | ISO collection timestamp. |

### Example post output

```json
{
  "postId": "5329401409704913",
  "bid": "RckRCEIGR",
  "url": "https://m.weibo.cn/status/RckRCEIGR",
  "uid": "2803301701",
  "authorName": "人民日报",
  "authorProfileUrl": "https://m.weibo.cn/u/2803301701",
  "text": "Public post text returned by Weibo",
  "createdAt": "Fri Aug 07 22:09:34 +0800 2026",
  "source": "微博视频号",
  "region": null,
  "repostsCount": 3441,
  "commentsCount": 796,
  "likesCount": 6140,
  "imageUrls": [],
  "videoUrl": "https://f.video.weibocdn.com/path/video.mp4",
  "isRepost": false,
  "originalPostId": null,
  "scrapedAt": "2026-08-07T21:06:52.809Z"
}
```

Counts and content above illustrate a real output shape. Weibo values change continuously, so a later run can differ.

### Example profile output

```json
{
  "uid": "2803301701",
  "screenName": "人民日报",
  "profileUrl": "https://m.weibo.cn/u/2803301701",
  "description": "人民日报法人微博。参与、沟通、记录时代。",
  "followersCount": 158000000,
  "followersCountText": "1.58亿",
  "followingCount": 3096,
  "postsCount": 151748,
  "verified": true,
  "verifiedReason": "《人民日报》法人微博",
  "scrapedAt": "2026-08-07T21:06:31.463Z"
}
```

### How much does it cost to scrape Weibo posts and profiles?

The Actor uses pay-per-event pricing:

- a one-time **$0.005 start event** per run;
- one `item` event for every post or profile record saved;
- no separate charge for API calls, pagination pages, images, or browser bootstrap.

At the BRONZE rate of **$0.020 per saved record**:

| Workflow | Charged records | Example cost |
| --- | ---: | ---: |
| One profile only | 1 | `0.005 + (1 × 0.020) = 0.025 USD` |
| One profile plus 10 posts | 11 | `0.005 + (11 × 0.020) = 0.225 USD` |
| Two profiles plus 40 posts | 42 | `0.005 + (42 × 0.020) = 0.845 USD` |

Your active Apify plan tier determines the exact per-record price shown in Console. Set small limits for evaluation, then raise them after validating the output.

### Scheduling public Weibo intelligence

Create an Apify Task with a stable UID list and schedule it at the cadence your analysis requires.

A useful pipeline is:

1. run the Actor daily;
2. export posts to a warehouse keyed by `postId`;
3. export profiles keyed by `uid`;
4. compare engagement values with the previous observation;
5. classify or translate new text downstream;
6. notify analysts only when your own thresholds are met.

The Actor returns snapshots. It does not maintain historical comparisons or send alerts by itself.

### Export and integration patterns

Use the output with:

- Apify dataset API for JSON pipelines;
- CSV or Excel exports for analyst review;
- Google Sheets through an Apify integration;
- webhooks after successful scheduled runs;
- data warehouses keyed by `postId` and `uid`;
- NLP workflows for translation, topic classification, or sentiment scoring;
- BI dashboards that compare public counts over time.

The Run page export button exports the default posts dataset. Select the `profiles` dataset under Storage to export profile records.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/weibo-posts-profiles-scraper').call({
  uids: ['2803301701'],
  mode: 'postsAndProfiles',
  maxPostsPerProfile: 10,
  maxItems: 10,
});

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

The run object also exposes run-scoped storage information for the `profiles` alias on Apify. You can open that dataset from the Run Storage tab or resolve it from `ACTOR_STORAGES_JSON` inside an integration Actor.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/weibo-posts-profiles-scraper').call(run_input={
    'uids': ['1699432410'],
    'mode': 'profilesOnly',
    'maxPostsPerProfile': 10,
    'maxItems': 10,
})

print(run['status'])
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~weibo-posts-profiles-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "uids": ["2803301701"],
    "mode": "postsOnly",
    "maxPostsPerProfile": 10,
    "maxItems": 10
  }'
```

Do not put an API token into source control. Use environment variables or your platform secret manager.

### Use with Apify MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/weibo-posts-profiles-scraper"
```

Equivalent configuration for **Claude Desktop, Cursor, and VS Code**:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/weibo-posts-profiles-scraper"
    }
  }
}
```

Example prompts:

- "Collect the ten latest public posts from Weibo UID 2803301701 and summarize recurring topics."
- "Extract profile metadata for UIDs 2803301701 and 1699432410 and compare their audience sizes."
- "Run my saved Weibo publisher-monitoring input and return post URLs with the highest like counts."

### Reliability and retry behavior

Weibo uses a public visitor challenge before it exposes mobile JSON data.

The Actor:

- retries browser bootstrap once;
- reuses one coherent anonymous session during the run;
- retries transient API responses with bounded exponential backoff;
- deduplicates posts by stable ID;
- keeps timeline preview text if only an optional long-text request fails;
- fails clearly when no supplied UID yields useful public data.

If one valid-looking UID is unavailable, the Actor logs it and continues with the remaining UIDs.

### Limits and data quality

- Weibo can change anonymous visitor behavior without notice.
- Recent timelines are not guaranteed to expose every historical post.
- Deleted, private, followers-only, or login-only content is excluded.
- Engagement counts are snapshots and can change after collection.
- Signed media URLs may expire; store files separately only when you are authorized to do so.
- `followersCount` converts rounded Chinese display units, so use `followersCountText` when exact display fidelity matters.
- Some optional fields are absent on some profiles or posts.
- A UID-based Actor is not a broad Weibo search API.

### Responsible use and legality

This Actor collects publicly available profile and post information.

You are responsible for:

- complying with Weibo's terms and applicable laws;
- respecting privacy, copyright, database, and personality rights;
- choosing a proportionate schedule and dataset size;
- protecting exported personal data;
- avoiding harassment, surveillance, discrimination, or automated adverse decisions;
- honoring deletion or access requests where required.

Public availability does not remove your legal and ethical obligations. Obtain professional advice for regulated or high-risk use cases.

### Troubleshooting: visitor session unavailable

Retry once with one known public UID and a small limit. A temporary visitor challenge or upstream congestion can block an otherwise valid UID.

The Actor intentionally does not ask you to paste a login cookie. If the small public test still fails, inspect the run log for the exact bootstrap or API error before scheduling another run.

### Troubleshooting: fewer posts than requested

Possible reasons include:

- the profile exposes fewer recent public posts;
- pinned or non-post cards were ignored;
- duplicated post IDs were removed;
- `maxItems` was reached by earlier UIDs;
- some records were deleted or login-only;
- Weibo returned an empty public timeline page.

`maxPostsPerProfile` and `maxItems` are upper bounds, not guaranteed counts.

### Troubleshooting: where are profile records?

Profiles are intentionally stored in the run-scoped `profiles` dataset rather than mixed with posts.

Open the run, choose **Storage**, select the Profiles dataset, and export it. In `postsOnly` mode the profile dataset remains empty. In `profilesOnly` mode the default posts dataset remains empty.

### FAQ

#### Does this Actor require a Weibo account?

No. It uses an anonymous public visitor session and does not accept passwords or user cookies.

#### Can it scrape private profiles or private posts?

No. Only data exposed through Weibo's public visitor surfaces is included.

#### Is this a Weibo API alternative?

It provides structured public post and profile records for the documented UID workflow. It is not an official Weibo API and does not implement posting, account management, comments, search, or follower graphs.

#### Can I use it for weibo gaming research?

Yes, when you already have the public UIDs of gaming publishers, teams, creators, or tournament accounts you are authorized to monitor. The Actor does not discover those UIDs for you.

#### Does it download images and videos?

No. It returns public media URLs when Weibo exposes them. Avoiding media downloads reduces runtime, transfer, and storage cost.

#### Can I monitor changes automatically?

Schedule the same Task and compare output snapshots downstream. Historical diffing and alert delivery are not built into this Actor.

### Related Automation Lab Actors

- [Bilibili Scraper](https://apify.com/automation-lab/bilibili-scraper) for public Chinese video-platform research.
- [Douban Scraper](https://apify.com/automation-lab/douban-scraper) for public Chinese movie, book, music, and community data.
- [RedNote Xiaohongshu Scraper](https://apify.com/automation-lab/rednote-xiaohongshu-scraper) for supported public lifestyle and creator workflows.

Choose this Actor when your source is a known list of public Weibo UIDs and you need recent posts plus profile context.

### Support

When reporting a problem, include:

- the non-sensitive input with a small public UID list;
- the Actor run ID;
- the output mode;
- the expected and observed record counts;
- the relevant error line from the run log.

Never send passwords, account cookies, private tokens, or private-profile data.

# Actor input Schema

## `uids` (type: `array`):

Up to 20 numeric UIDs or public weibo.com / m.weibo.cn profile URLs. One value per line.

## `mode` (type: `string`):

Collect posts and profiles, posts only, or profile metadata only.

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

Maximum recent public posts to save for each UID. Ignored in profiles-only mode.

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

Maximum post records saved across all UIDs. Profile records are stored separately and do not consume this limit.

## Actor input object example

```json
{
  "uids": [
    "2803301701"
  ],
  "mode": "postsAndProfiles",
  "maxPostsPerProfile": 10,
  "maxItems": 20
}
```

# Actor output Schema

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

Default dataset containing recent public Weibo posts.

## `profiles` (type: `string`):

Dataset containing one public profile record for each resolved UID.

# 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 = {
    "uids": [
        "2803301701"
    ],
    "mode": "postsAndProfiles",
    "maxPostsPerProfile": 10,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/weibo-posts-profiles-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 = {
    "uids": ["2803301701"],
    "mode": "postsAndProfiles",
    "maxPostsPerProfile": 10,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/weibo-posts-profiles-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 '{
  "uids": [
    "2803301701"
  ],
  "mode": "postsAndProfiles",
  "maxPostsPerProfile": 10,
  "maxItems": 20
}' |
apify call automation-lab/weibo-posts-profiles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/weibo-posts-profiles-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/pK2GpsA0abhpa4kzI/builds/Mge7dBfp8jvPvt9D5/openapi.json