# Weibo Following Accounts Scraper (`automation-lab/weibo-public-following`) Actor

Export publicly visible accounts followed by Weibo creator UIDs, with bio, profile URLs, audience counts and verification. Reports incomplete coverage at sign-in boundaries; no credentials or restricted-list access.

- **URL**: https://apify.com/automation-lab/weibo-public-following.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 item extracteds

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 Following Accounts Scraper

Export **Weibo following accounts** from the public outbound lists of supplied creator UIDs. Each row identifies the creator and an account they follow, with its visible bio, profile URL, audience signals and verification.

**Important:** this is a public visible-window export, not a complete social graph. In our current tests Weibo exposes 20 accounts per creator anonymously, then requires sign-in. This Actor stops at that boundary. Read the coverage summary before interpreting missing relationships.

### What does it collect?

The Actor reads Weibo's outbound-following list, not inbound fans, recommendations, posts or search results. It uses an anonymous browser session and does not accept cookies, passwords or account credentials. It never unlocks restricted lists.

Returned records are suitable for bounded creator-interest research, public network sampling and repeatable spreadsheet exports. They do not establish a creator's entire network or the reason for a relationship.

### Who is it for?

- Researchers exploring publicly visible creator interests.
- Marketing analysts comparing observed connections across supplied creators.
- Data teams exporting a timestamped public sample into an existing reporting pipeline.

Do not use the results for sensitive inference, harassment or automated contact campaigns.

### Why use this Actor?

A dataset row preserves the relationship's source creator instead of presenting unrelated account profiles. Counts retain both source text and normalized numeric values. Each source has a coverage entry, distinguishing a user limit from a source sign-in boundary.

Repeated source UIDs are processed once. An account followed by two supplied creators appears twice, once for each relationship. The Actor does not mix Weibo's recommended-user cards into following results.

### Getting started

1. Copy a numeric UID from a public profile such as `https://weibo.com/u/1195242865`.
2. Enter that numeric string in `uids`; URLs themselves are not accepted.
3. Choose a small global `maxItems` and a per-creator `maxPages`.
4. Start the Actor and open **Followed accounts**.
5. Open **Coverage summary** and inspect `complete` and `stopReason` before analyzing the dataset.
6. Export JSON, CSV or Excel using Apify's dataset tools.

Example input:

```json
{
  "uids": ["1195242865"],
  "maxItems": 20,
  "maxPages": 3
}
```

This starter example requests 20 public relationships. With maxItems=100, our source tests still return only 20, with `complete: false` and `source_sign_in_boundary`. The source can change its public visibility.

### Input parameters

| Field | Meaning |
| --- | --- |
| `uids` | Required, 1–20 numeric UID strings of 5–20 digits. Whitespace is trimmed; duplicate source UIDs are removed. |
| `maxItems` | Global unique creator/account-pair limit, default 100, range 1–1000. Sources run sequentially in input order; later sources may not start. |
| `maxPages` | Per-creator outbound-page limit, default 3, range 1–50. Stops earlier at source restrictions, exhaustion, billing limit or the global row limit. |

Zero and unlimited are unsupported. These limits are ceilings, not guarantees. A larger page limit does not provide signed-in access. Pages typically contain 20 accounts. No additional filtering or discovery mode is provided.

### Extracted data

| Field | Meaning |
| --- | --- |
| `sourceUid`, `sourceProfileUrl` | Creator whose public following list supplied the relationship. |
| `uid`, `screenName`, `profileUrl` | Followed account identity and canonical public profile link. |
| `description`, `avatarUrl` | Public bio and available HTTPS avatar URL; null when absent. |
| `followersCount`, `followersCountText` | Visible audience count and original source text. Chinese 万/亿 counts may be rounded. |
| `followingCount`, `postsCount` | Visible counts for the followed account, not proof of list completeness. |
| `verified`, `verifiedReason` | Public verification information. |
| `page`, `scrapedAt` | One-based source page and UTC observation time. |

IDs are strings. Missing optional metadata is null rather than invented. No raw response fields, session tokens, private contact details or signed-in data are exported.

### Output example

This anonymized example follows the structure of current tested rows; names and IDs below are placeholders.

```json
{
  "sourceUid": "1234567890",
  "sourceProfileUrl": "https://weibo.com/u/1234567890",
  "uid": "2345678901",
  "screenName": "Example creator",
  "profileUrl": "https://weibo.com/u/2345678901",
  "description": "Example biography.",
  "avatarUrl": null,
  "followersCount": 152000,
  "followersCountText": "15.2万",
  "followingCount": 250,
  "postsCount": 3000,
  "verified": true,
  "verifiedReason": "Example verified creator",
  "page": 1,
  "scrapedAt": "2026-10-13T20:00:00.000Z"
}
```

### Coverage and incomplete lists

`RUN_SUMMARY` in the run's default key-value store contains `saved` and `sources`. Each processed source reports its UID, collected count, the source's reported total where available, `complete` and `stopReason`.

- `source_exhausted`: the public list ended or the returned count reached the source total.
- `source_sign_in_boundary`: some public accounts were collected, but further pages require sign-in. Coverage is incomplete.
- `global_limit` or `page_limit`: a requested limit stopped collection; coverage is incomplete.
- `source_no_next_page`: source supplied no usable next page; full coverage is not established.
- `global_limit_not_started`: this creator was not fetched.
- `billing_limit`: the run's event budget stopped output.

A reported total larger than collected rows does not mean those missing rows are publicly accessible. A zero-row restricted first page fails clearly, rather than claiming a complete empty list. Invalid profiles, unexpected response shapes and exhausted network errors fail the run; any existing dataset rows then represent partial work.

### How much does it cost to export Weibo following accounts?

Pay-per-event pricing includes a **$0.005 start fee** and an **item** event for each saved public creator/account relationship. No item fee is charged for duplicate, failed or unavailable records. Coverage summaries have no separate charge.

| Plan | Per relationship |
| --- | --- |
| FREE | $0.002484 |
| BRONZE | $0.00216 |
| SILVER | $0.0016848 |
| GOLD / PLATINUM / DIAMOND | $0.001296 |

Spend tiers follow your qualifying aggregate monthly Apify Store spend, not this Actor's individual run volume. Estimated BRONZE pricing examples including one start fee: one relationship totals $0.00716; 20 total $0.0482; 100 total $0.221. Source visibility determines actual output; do not assume a request for 100 produces 100. The current Actor pricing card is authoritative. A failed run after the start event can incur the start fee.

### Integrations

Export datasets into Google Sheets, a warehouse or your own analysis code using Apify's integration and API features. Join on the pair `sourceUid` and `uid`. Preserve `scrapedAt` and the corresponding coverage report.

Scheduled runs can produce recurring snapshots, but this Actor does not maintain history, compute changes or send alerts itself. Compare only equivalent visible windows. A missing row in an incomplete snapshot is not proof of an unfollow.

### API usage

Keep your Apify token in an environment variable rather than a shared document.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~weibo-public-following/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"uids":["1195242865"],"maxItems":20,"maxPages":2}'
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/weibo-public-following').call({
  uids: ['1195242865'], maxItems: 20, maxPages: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 20 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/weibo-public-following').call(
    run_input={'uids': ['1195242865'], 'maxItems': 20, 'maxPages': 2})
items = client.dataset(run['defaultDatasetId']).list_items(limit=20).items
print(items)
```

Also retrieve `RUN_SUMMARY` from `defaultKeyValueStoreId`. Check the run's terminal status before treating dataset output as a successful snapshot.

### MCP and AI assistants

Select the stable Actor-specific endpoint:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/weibo-public-following'
```

#### Claude Desktop, Cursor and VS Code

For compatible desktop/editor clients:

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

Discover actual tool names and input schemas with read-only `tools/list`. Actor selection also exposes run/data helper tools; it is not exactly one tool. An example prompt is: “Collect at most 20 publicly visible followed accounts for this creator UID, then report the coverage limitations.”

Start once and retain the run and storage IDs. Choose server `waitSecs: 30` (supported range 0–45) and configure a **client request timeout of 45 seconds**, exceeding the server wait by 15 seconds for transport. If a call returns before completion, follow that same run using `get-actor-run` with `{"runId":"<returned run ID>","waitSecs":0}` and bounded backoff (2, 4, 8 seconds, capped at 10, with a total 120-second deadline). Cap each client request timeout by the remaining deadline; report pending with the run ID at the deadline. On client timeout recover the known run, never start another just to poll; if its ID is unknown, report uncertainty. Report failed status and partial rows honestly.

After success, take the dataset ID from `storages.datasets.default.id` in the MCP run response (`defaultDatasetId` in the public run API). The discovered `get-dataset-items` schema uses a comma-separated **string** for `fields`. Example tool arguments:

```json
{
  "datasetId": "<returned dataset ID>",
  "limit": 20,
  "offset": 0,
  "fields": "sourceUid,uid,screenName,description,profileUrl,followersCount,followingCount,scrapedAt",
  "clean": false,
  "desc": false
}
```

Use untransformed rows: no filtering/unwinding. Continue with the same dataset and `offset: 20`, then 40, etc., using the source pagination metadata, not a host-transformed count. Stop at source exhaustion or the budget; report the continuation offset and whether results are partial/truncated.

Read successful datasets in pages of 20, at most 100 source rows and 64 KiB of UTF-8 result content admitted to model context. Enforce this byte budget in host-side processing; if the client cannot intercept oversized results, do not claim a hard byte guarantee. Track source offsets and disclose truncation or partial coverage. Retrieve the coverage summary too. Full exports belong in storage, not unbounded model context. Tool discovery and caching depend on the client; no numeric token-saving promise is made.

### Reliability and troubleshooting

The Actor uses a sequential anonymous browser context, resource blocking and bounded transient retries. A bootstrap failure may renew the visitor context once. It does not use an automatic residential fallback and does not retry a sign-in boundary to evade it.

**Why only 20 accounts?** That is the observed anonymous public window for the tested creators. More pages require sign-in. Increasing limits does not remove this boundary.

**Why did the run fail?** Verify a numeric public UID. The source may restrict the first page, change its response or reject visitor bootstrap. Unexpected challenges are failures, not empty lists.

**Can I get fans, posts or full signed-in networks?** No. Fans and posts are different products; credential-dependent networks are outside this Actor's public scope.

### Legality and responsible use

Use public data only for lawful, proportionate research. Respect Weibo's terms, applicable privacy rules and the rights of account holders. Public visibility does not authorize sensitive inference or unrestricted redistribution. This Actor is not affiliated with Weibo and makes no guarantee of legal suitability for your specific use.

The Actor uses no AI at runtime and sends no collected accounts to an AI model. Anonymous session cookies live only for the current source and are discarded when its browser context closes. Output remains in your Apify dataset and key-value store under your account's retention settings; you can delete these stores through Apify. No cross-run cache is retained by this Actor. Company-owned Apify compute and storage costs are included in the listed events; no separate paid service account is required.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ and support

**Is the dataset complete?** Only when the per-source summary explicitly says `complete: true`. An anonymous 20-account window is not a full network.

**Does a missing account mean it was unfollowed?** No. Source ordering and public visibility can change between incomplete samples.

**Where can I get help?** Open an issue on this Actor's Apify Store page with the run link and a safe description. Never post credentials. Source outages and restricted pages can prevent collection.

### Related Actors

- [Weibo Posts and Profiles Scraper](https://apify.com/automation-lab/weibo-posts-profiles-scraper) for post and profile records rather than outbound relationships.
- [Weibo Hot Search Rankings Scraper](https://apify.com/automation-lab/weibo-public-hot-search-rankings) for public ranked topics rather than creator networks.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/weibo-public-following/changelog.md

# Actor input Schema

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

1–20 numeric Weibo UID strings, not profile URLs. Whitespace is trimmed and duplicate source UIDs are processed once. Output identifies each creator-to-followed-account relationship, not fans or recommendations.

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

Global run limit of unique creator/account pairs, from 1 to 1000 (default 100). Sources are processed in input order; later UIDs may not be started. Zero and unlimited are unsupported. Source restrictions and billing limits can reduce the returned count.

## `maxPages` (type: `integer`):

Fetch at most 1–50 outbound-following pages per UID (default 3), stopping earlier at maxItems, source exhaustion, or sign-in/restricted-list boundaries. A page typically contains 20 accounts. This does not unlock signed-in pages or guarantee full coverage; see RUN_SUMMARY for each source's stop reason.

## Actor input object example

```json
{
  "uids": [
    "1195242865"
  ],
  "maxItems": 20,
  "maxPages": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing unique creator/account pairs.

## `summary` (type: `string`):

Per-creator collected count, completeness and stop reason. Sign-in boundaries are incomplete, not empty full lists.

# 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": [
        "1195242865"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/weibo-public-following").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": ["1195242865"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/weibo-public-following").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": [
    "1195242865"
  ],
  "maxItems": 20
}' |
apify call automation-lab/weibo-public-following --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/weibo-public-following"
        }
    }
}
```

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/AXKeLX2TaHt1MI2GZ/builds/Us2bRielXh9967LxS/openapi.json