# Chinese Brand Monitor: Weibo + RedNote + Bilibili Aggregator (`zhorex/chinese-brand-monitor`) Actor

Track brand mentions across China's top 5 social/content platforms in a single call. Normalized output, sentiment-tagged, cross-platform deduplicated. Enterprise-grade coverage at $0.045/mention. Built for brand monitoring agencies, DTC e-commerce, China-watcher funds.

- **URL**: https://apify.com/zhorex/chinese-brand-monitor.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** AI, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $45.00 / 1,000 brand mention aggregateds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Chinese Brand Monitor — Weibo + RedNote + Bilibili + Douban + Xueqiu Aggregator

Track every mention of your brand across China's top 5 social and content platforms — **Weibo, RedNote (Xiaohongshu), Bilibili, Douban, and Xueqiu** — in a single API call. The fastest way to monitor Chinese consumer sentiment, KOL endorsements, viral content, and crisis signals at **$0.045 per mention**. No subscription, no setup fee, no annual contract. The best **Synthesio alternative** and **Brandwatch alternative** for Chinese platform coverage in 2026.

> Enterprise tools like Synthesio, Brandwatch, Meltwater, and Talkwalker charge **$50K+/year** for Chinese platform coverage. This Actor delivers Weibo + Xiaohongshu + Bilibili + Douban + Xueqiu in one normalized feed at **$0.045 per mention — pay only for what you pull**. No subscription, no minimum, no setup fee. Built for brand monitoring agencies, DTC brands entering China, China-watcher hedge funds, and AI training data teams.

### How to monitor Chinese brand mentions in 3 easy steps

1. **Go to the [Chinese Brand Monitor](https://apify.com/zhorex/chinese-brand-monitor) page** on Apify and click **"Try for free"**
2. **Enter your brand keyword** (Chinese or English — e.g. `李宁`, `Li-Ning`, `Apple`, `耐克`, `NIKE`) and pick the platforms you want to monitor
3. **Click "Run"**, wait for the aggregator to finish, then **download your data** in JSON, CSV, or Excel format — or wire it into a daily/hourly Apify Schedule for continuous monitoring

No coding required. No API key. No VPN. Works with Apify's free plan.

> 🏢 **Running a production brand monitoring pipeline?**
>
> If you're tracking 5+ brands, polling daily or hourly, or pulling >10K mentions/month, I offer custom output schemas matched to your data warehouse, dedicated proxy infrastructure for sustained throughput, schema stability SLA (no breaking changes without 30-day notice), and volume pricing above 100K mentions/month.
>
> DM me on Apify, open an Issue with subject **"Enterprise inquiry"**, or email **samimassis2002@gmail.com** with subject **"Chinese Brand Monitor enterprise"**.

### Table of contents

- [What it does](#what-it-does) — single-call aggregation across 5 platforms
- [Platforms covered](#platforms-covered) — Weibo, RedNote, Bilibili, Douban, Xueqiu
- [Who buys this Actor](#who-buys-this-actor) — typical buyer profiles and spend
- [Example use cases](#example-use-cases) — 6 concrete workflows with cost estimates
- [Pricing](#pricing) — $0.045/mention, billed only on canonical records
- [Example input + output](#example-input) — sample run config and normalized record
- [Scrape with Python, JavaScript, or no code](#scrape-chinese-brand-mentions-with-python-javascript-or-no-code) — copy-paste integration
- [Output schema reference](#output-schema-reference) — every field documented
- [Optional cookies](#optional-cookies) — unlock higher recall and rate limits
- [FAQ](#faq) — common questions about Chinese brand monitoring
- [Compliance posture](#compliance-posture) — what we do and don't access

### What it does

- Single brand-keyword input → mentions across 5 Chinese platforms in one call
- Normalized output schema (no per-platform parsing needed downstream — same shape for every record regardless of platform)
- Lexicon-based Chinese sentiment scoring (polarity + numeric score per mention)
- Cross-platform deduplication (the same KOL post reposted across platforms = one canonical record with a `crossPlatformReposts` array — no double-billing)
- Filtered by recency (default 7-day lookback, configurable up to 30 days)
- Author identity in every record (handle, follower count, verified flag) — weight your dashboard by reach, not by raw count
- Engagement metrics (likes, comments, shares, views where the platform exposes them)

### Platforms covered

| Platform | What it captures | Why it matters for brand monitoring |
|---|---|---|
| **Weibo (微博)** | Public microblog mentions, KOL posts, hot search trending | China's Twitter. 580M+ users. Where consumer crises break first and KOL endorsements reach hundreds of millions in hours. |
| **RedNote / Xiaohongshu (小红书)** | Lifestyle and consumer brand notes, first-person product reviews, unboxings | 300M+ users. The single highest-trust channel for Chinese consumer purchase decisions in beauty, skincare, fashion, food, travel. |
| **Bilibili (B站)** | Video titles, descriptions, and creator mentions | China's YouTube. 300M+ users. Where Gen Z consumer brand affinity forms and where unboxing / review culture lives. |
| **Douban (豆瓣)** | Movie / book / music subject mentions, brand tie-ins, audiobooks, soundtracks | 200M+ users. Long-form opinion-rich content — densest source of detailed consumer attitude data outside Zhihu. |
| **Xueqiu (雪球)** | Stock cashtag and corporate mentions for listed brands (NASDAQ:JD, BABA, HK:00700, A-share) | 20M+ users, financial-grade signal. Critical if your brand is publicly listed — finance KOLs move retail sentiment fast. |

Together these five cover the spectrum of Chinese consumer signal: broad public opinion (Weibo), high-trust consumer reviews (RedNote), Gen-Z video sentiment (Bilibili), long-form opinion (Douban), and investor sentiment (Xueqiu). For most consumer brands, monitoring any 3 of these in real time is a leading indicator that beats your CRM dashboards by 2-6 weeks.

### Who buys this Actor

| Buyer profile | Use case | Typical monthly spend |
|---|---|---|
| **Brand monitoring agency** | Daily monitoring across 5-20 client brands, per-client dashboard, $2-5K/client/month bill-out | $500–$7,000/mo |
| **DTC brand entering China** | Daily monitoring on own brand + 2-3 competitors, weekly sentiment report to CMO | $150–$500/mo |
| **Crisis monitoring / PR team** | Hourly polling, negative-sentiment + KOL-reach filter, Slack alerts on inflection | $200–$800/mo |
| **China-watcher hedge fund / equity research** | Daily Xueqiu + Weibo monitoring on 10-30 portfolio tickers (BABA, JD, PDD, NIO, BYD, POP MART, Yum China, etc.) | $500–$2,500/mo |
| **AI / LLM training data team** | One-time and periodic bulk pulls for Chinese-language SFT / RLHF corpora with explicit sentiment labels | $500–$3,000 per pull |
| **Influencer / KOL research agency** | Weekly category keyword pulls, filter by `authorVerified` + `authorFollowerCount`, candidate KOL lists | $100–$500/mo |
| **Localization / cross-cultural research** | Periodic pulls to track brand reception across platforms; academic + market research | $50–$300/mo |

If you're in any of these buckets and you're not actively monitoring all 5 platforms, you're flying blind on the world's second-largest consumer market.

### Example use cases

#### 1. Daily brand health dashboard
Cron daily at 8am local time, single brand keyword, 7-day lookback, sentiment + dedup enabled. Push the canonical mentions to your BI tool (Looker / Metabase / Hex / Sigma) for a stacked-by-platform sentiment chart, follower-weighted reach total, and top-10 highest-engagement mention list. **Typical volume**: 100 mentions/day × 30 days = 3,000/mo. **Cost: ~$135/mo per brand.** Compared to $4,000/mo for a Synthesio seat covering the same platforms.

#### 2. Crisis monitoring (hourly polling + Slack alerts)
Cron every hour, 1-day lookback, sentiment-enabled, filter for `sentiment.polarity == "negative"` AND `authorFollowerCount > 10000`. Pipe matching records to a Slack webhook that pings #pr-alerts. **Typical volume**: ~200 mentions/day amortized = 6,000/mo. **Cost: ~$270/mo per brand.** A single prevented PR crisis pays for the entire year.

#### 3. Pre-launch competitor intelligence (one-off pull)
Before launching a new SKU in China, pull 30 days of mentions on each competitor brand keyword across all 5 platforms. Analyze: which platforms each competitor over-indexes on, which KOLs are talking about them, what sentiment dominates, what product attributes get the most positive vs negative mentions. **Typical volume**: 5 competitors × 500 mentions = 2,500 mentions one-time. **Cost: ~$112 one-time per quarter.**

#### 4. KOL identification and vetting
Weekly run on your category keyword (`护肤` for skincare, `球鞋` for sneakers). Filter for `authorVerified == true` AND `authorFollowerCount > 50000`. Sort by `engagementMetrics.likes` descending. Top 20 = your candidate KOL list, ranked by actual cultural reach not paid impressions. **Typical volume**: 2,000 mentions/mo. **Cost: ~$90/mo per category.**

#### 5. China-watcher hedge fund alt-data
Daily run on each portfolio ticker (BABA, JD, PDD, BIDU, NIO, BYD, ANTA, Yum China, POP MART, etc.). Pull mentions from Xueqiu (financial sentiment) + Weibo (consumer sentiment) + RedNote (brand affinity). Build a sentiment-velocity feature: 7-day mention delta + polarity shift. **Typical volume**: 22,000/mo across 20 tickers. **Cost: ~$990/mo.** Compare to: Bloomberg China consumer alt-data feed, $80K–$200K/year minimum.

#### 6. AI / LLM training data corpus
One-time bulk pull across 50 consumer-brand keywords. 1,000 mentions per brand = 50K labeled Chinese-language consumer text records with explicit sentiment polarity. Drop into your SFT or RLHF pipeline. **Typical volume**: 50,000 mentions one-time. **Cost: ~$2,250.** Compare to: licensing a comparable academic corpus from Trinity College Dublin or Tsinghua, $15K–$50K, single-use license, 6-month delivery.

### Pricing

- `mention-aggregated` event: **$0.045 per canonical mention** (billed only on deduplicated records — cross-platform duplicates are free)
- No subscription. No setup fee. No minimum spend. No annual contract.
- **Why premium vs single-platform scrapers**: Running 5 scrapers separately and reconciling output downstream (parsing 5 different shapes, deduping reposts, joining sentiment) is a 4-6 hour engineering job per pipeline plus ongoing maintenance. The aggregator does it in one call with one billing line.

#### Realistic costs

| Workflow | Volume | Cost |
|---|---|---|
| Single brand, daily monitoring, 100 mentions/day | 3,000 mentions/mo | **~$135/mo** |
| 10 brands, daily monitoring, 500 mentions/brand/day | 150,000 mentions/mo | **~$6,750/mo** |
| Crisis monitoring, hourly, 1 brand | 5,000 mentions/mo | **~$225/mo** |
| AI training corpus (one-time bulk pull) | 50,000 mentions | **~$2,250 one-time** |
| Quarterly competitor intelligence (5 brands × 500 mentions) | 2,500 mentions/quarter | **~$112/quarter** |

Compared to a $4,000/mo Synthesio or Brandwatch seat for equivalent Chinese platform coverage, the 10-brand daily workflow above is **~40% cheaper** and you own the raw data — no walled-garden dashboard, no annual contract, no per-seat licensing.

Apify platform compute costs (RAM-seconds) are charged separately and are negligible (typically <$0.10 per run for the default config).

### Example input

```json
{
    "brandKeyword": "李宁",
    "platforms": ["weibo", "bilibili", "rednote", "douban", "xueqiu"],
    "maxMentionsPerPlatform": 200,
    "lookbackDays": 7,
    "sentimentAnalysis": true,
    "deduplication": true
}
````

One brand keyword, one call, mentions back from all 5 platforms. `lookbackDays` filters per-platform so you only get fresh content; `deduplication` collapses cross-platform reposts; `sentimentAnalysis` tags every record.

### Scrape Chinese brand mentions with Python, JavaScript, or no code

You can use Chinese Brand Monitor directly from the Apify Console (no code), or integrate it into your scripts.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
    "brandKeyword": "李宁",
    "platforms": ["weibo", "bilibili", "rednote", "douban", "xueqiu"],
    "maxMentionsPerPlatform": 100,
    "lookbackDays": 7,
    "sentimentAnalysis": True,
    "deduplication": True,
})

for mention in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{mention['platform']}] {mention['sentiment']['polarity']}: "
          f"{mention['contentSnippet']} (reach: {mention['authorFollowerCount']})")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('zhorex/chinese-brand-monitor').call({
    brandKeyword: '李宁',
    platforms: ['weibo', 'bilibili', 'rednote', 'douban', 'xueqiu'],
    maxMentionsPerPlatform: 100,
    lookbackDays: 7,
    sentimentAnalysis: true,
    deduplication: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((m) => {
    console.log(`[${m.platform}] ${m.sentiment.polarity}: ${m.contentSnippet}`);
});
```

#### Scheduled / recurring runs (where PPE compounds)

The real value of this Actor is in **scheduled monitoring**, not one-off pulls. Use [Apify Schedules](https://docs.apify.com/platform/schedules) with a cron expression:

- `0 8 * * *` — daily at 8am for brand health dashboards
- `0 * * * *` — hourly for crisis monitoring
- `*/15 * * * *` — every 15 minutes during product launches or crisis response

Each scheduled run hits the same Actor with your saved input config, pushes to the same dataset, and bills only on the new canonical mentions.

### Example output (one mention record)

```json
{
    "mentionId": "weibo_4923475823745",
    "platform": "weibo",
    "brandKeyword": "李宁",
    "brandMatchType": "exact",
    "content": "李宁的新款跑鞋质量真不错，比之前的耐克舒服多了！",
    "contentSnippet": "李宁的新款跑鞋质量真不错…",
    "language": "zh-CN",
    "authorId": "1234567890",
    "authorName": "运动达人",
    "authorFollowerCount": 12500,
    "authorVerified": true,
    "publishedAt": "2026-05-15T14:32:11+00:00",
    "engagementMetrics": {
        "likes": 234,
        "comments": 18,
        "shares": 42,
        "views": null
    },
    "url": "https://weibo.com/1234567890/4923475823745",
    "mediaUrls": ["https://wx1.sinaimg.cn/large/..."],
    "sentiment": {
        "polarity": "positive",
        "score": 0.72,
        "method": "lexicon"
    },
    "crossPlatformReposts": [
        { "platform": "rednote", "url": "https://www.xiaohongshu.com/explore/abc123", "publishedAt": "2026-05-15T15:01:08+00:00" }
    ],
    "scrapedAt": "2026-05-16T10:00:00+00:00"
}
```

### Output schema reference

| Field | Type | Notes |
|---|---|---|
| `mentionId` | string | `{platform}_{platformId}` — unique within a run |
| `platform` | enum | `weibo` / `bilibili` / `rednote` / `douban` / `xueqiu` |
| `brandKeyword` | string | Echo of input — useful when piping to a multi-brand store |
| `brandMatchType` | enum | `exact` / `partial` / `tag` |
| `content` | string | Full mention text |
| `contentSnippet` | string | First 100 chars for preview UIs |
| `language` | string | `zh-CN` / `en` / `mixed` / `und` |
| `authorId` | string|null | Platform-specific user id |
| `authorName` | string|null | Display name / screen name |
| `authorFollowerCount` | int|null | Where the platform exposes it |
| `authorVerified` | bool | Platform-specific verification flag |
| `publishedAt` | ISO 8601 | UTC; empty string if platform doesn't expose it |
| `engagementMetrics` | object | `{likes, comments, shares, views}` — null per-field where unsupported |
| `url` | string | Canonical mention URL |
| `mediaUrls` | string\[] | Images / video URLs |
| `sentiment` | object|absent | Only present when `sentimentAnalysis: true` |
| `crossPlatformReposts` | object\[] | Only populated when `deduplication: true`; empty array otherwise |
| `scrapedAt` | ISO 8601 | When the aggregator extracted this record |

### What this Actor is NOT

- **Not a real-time stream.** Poll-based — 5-15 minute effective refresh is realistic. If you need millisecond latency, this isn't the right tool.
- **Not WeChat coverage.** WeChat has no public scraping interface; trying is a fast way to get accounts banned.
- **Not Douyin (TikTok China).** Out of scope for v0.1 — under evaluation for the roadmap.
- **Not Toutiao** (news aggregator) — separate scraper if needed.
- **Not a Synthesio replacement at the largest enterprise scale.** Synthesio also covers TV, podcasts, news, and provides a managed-service layer. This Actor is the **data layer**; bring your own BI / dashboard / alerting stack.

### Platform-specific coverage notes

- **Weibo**: Public microblog search. Works anonymously by default; pass `cookieStrings.weibo` for higher recall on mid-tail keywords and reduced rate limiting.
- **Bilibili**: Video search (titles + descriptions + creator metadata). No login required.
- **RedNote (Xiaohongshu)**: v0.1 returns the first page of search results (typically 10-20 mentions per call). For deeper coverage (infinite scroll, comments, profile enrichment), use [`zhorex/rednote-scraper`](https://apify.com/zhorex/rednote-scraper) directly.
- **Douban**: Movie + book + music subject search, budget split across the three categories. Surfaces brand tie-ins, audiobooks, soundtracks, branded titles.
- **Xueqiu**: Higher recall on free-text brand search when `cookieStrings.xueqiu` is provided. Degrades gracefully to a trending-feed + keyword-filter path when no cookie is supplied — lower recall but never empty.

### Optional cookies

Pass per-platform cookies under the `cookieStrings` input field to unlock higher recall and rate limits. The field is marked as a secret in the input schema — values are encrypted at rest by Apify.

```json
{
    "brandKeyword": "李宁",
    "cookieStrings": {
        "weibo": "<paste your weibo.com Cookie header here>",
        "xueqiu": "<paste your xueqiu.com Cookie header here>",
        "rednote": "<paste your xiaohongshu.com Cookie header here>"
    }
}
```

How to grab a cookie string: open the platform's website in your browser, sign in if you have an account, then DevTools → Application → Cookies → copy the full Cookie header value. Cookies are optional — the actor degrades gracefully when omitted.

### FAQ

#### What is the best Chinese brand monitoring tool in 2026?

The [Chinese Brand Monitor by Zhorex](https://apify.com/zhorex/chinese-brand-monitor) is the best Chinese brand monitoring tool on Apify in 2026 for teams that need cross-platform coverage without a five-figure annual contract. It aggregates Weibo, RedNote (Xiaohongshu), Bilibili, Douban, and Xueqiu in one normalized output at $0.045 per mention. No subscription, no minimum spend, no annual contract.

#### How is this different from Synthesio, Brandwatch, Talkwalker, or Meltwater?

Enterprise platforms like Synthesio, Brandwatch, Meltwater, and Talkwalker start at $50,000+/year for Chinese platform coverage with annual contracts and per-seat licensing. Chinese Brand Monitor is **pay-per-mention** at $0.045 — typically 5-10x cheaper for mid-market teams who don't need TV / podcast / news coverage and already have their own BI stack. You own the raw data, no walled-garden dashboard.

#### How much does it cost to monitor a Chinese brand?

For a typical daily-monitoring workflow on one brand: **~$135/mo** (100 mentions/day × 30 days × $0.045). For a 10-brand agency portfolio: **~$6,750/mo**. For a one-time AI training corpus of 50K mentions: **~$2,250 one-time**. See the [Realistic costs](#realistic-costs) table for more examples.

#### Is there an official Weibo / RedNote / Bilibili / Douban / Xueqiu API for brand monitoring?

No. None of these platforms offer a public official API for cross-platform brand monitoring. Weibo's developer API requires a Chinese business license. RedNote / Xiaohongshu has no public API. Bilibili / Douban / Xueqiu APIs are deprecated, geo-restricted, or auth-gated. This Actor is the **best Chinese social listening alternative** for international teams that need the data without Chinese business registration.

#### Can I monitor in real time?

Effective refresh is **5-15 minutes** with Apify Schedules. For most brand monitoring and crisis response use cases this is more than fast enough — KOL posts surface within hours, not seconds. If you need millisecond latency, you're looking at a streaming API and this isn't the right tool.

#### Can I scrape Chinese brand mentions in Python?

Yes. Install the Apify Python client (`pip install apify-client`), then call `zhorex/chinese-brand-monitor` from any Python script. See the Python code example above. Works identically in JavaScript / Node, Go, Ruby, or any language with HTTP — Apify exposes a REST API for every actor.

#### Is scraping Weibo / RedNote / Bilibili / Douban / Xueqiu legal?

This Actor accesses only publicly available content on each platform — the same content any anonymous browser visitor can see. No login bypass, no private accounts, no DMs, no follower lists. Optional `cookieStrings` are user-supplied and used only to raise recall and rate limits, never to bypass authentication. Always review your local laws and each platform's terms of service for your specific use case.

#### Does this require a Chinese business license or VPN?

No. The Actor runs on Apify's infrastructure with residential proxy support and is globally accessible. You don't need a Chinese business registration, a Chinese mobile number, or a VPN. Just an Apify account.

#### What is `crossPlatformReposts` and why does it matter?

When a viral post spreads from Weibo to RedNote (or any combination), this Actor detects the near-duplicate using SimHash similarity and merges them into a single canonical record — with the repost paths preserved in a `crossPlatformReposts: [...]` array. **You don't pay twice for the same mention**, and you get a free virality signal: any record with `crossPlatformReposts.length >= 2` is a cross-platform breakout moment, often before mainstream Chinese media picks it up.

#### How do I track Chinese KOLs?

Every mention record includes `authorName`, `authorFollowerCount`, `authorVerified`, and the engagement metrics for that post. Filter the output for `authorVerified == true` AND `authorFollowerCount > 50000`, sort by engagement, and you have a KOL candidate list ranked by actual cultural reach. Use the [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) for deeper profile enrichment on identified KOLs.

#### Can I use this for Chinese sentiment analysis / AI training data?

Yes — it's one of the highest-value use cases. Bulk-pull mentions across diverse brand keywords with `sentimentAnalysis: true` to get pre-labeled Chinese-language consumer text records with explicit positive / neutral / negative polarity and a numeric sentiment score. Drop into your SFT or RLHF pipeline for Chinese consumer-domain LLM fine-tuning.

#### What if I need deeper coverage of one platform?

Use the dedicated single-platform actors:

- [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) — full comment trees, hot search, user posts
- [RedNote (Xiaohongshu) Scraper](https://apify.com/zhorex/rednote-xiaohongshu-scraper) — infinite scroll, comments, profiles, videos
- [Douban Scraper](https://apify.com/zhorex/douban-scraper) — long-form reviews, group discussions
- [Xueqiu Scraper](https://apify.com/zhorex/xueqiu-scraper) — ticker-tagged posts, KOL tracking
- [JD.com Scraper](https://apify.com/zhorex/jd-scraper) — JD product detail extraction

The aggregator is for **recurring cross-platform brand monitoring** with normalized output. The single-platform scrapers are for **one-off deep extraction** inside one platform.

### Built on zhorex's Chinese platform scraper suite

This aggregator complements the single-platform scrapers in the same suite:

- [Weibo Scraper](https://apify.com/zhorex/weibo-scraper) — deep microblog scraping with full comment trees
- [RedNote Scraper](https://apify.com/zhorex/rednote-scraper) — Xiaohongshu notes + infinite scroll + profile enrichment
- [Douban Scraper](https://apify.com/zhorex/douban-scraper) — movies / books / music with full reviews
- [Xueqiu Scraper](https://apify.com/zhorex/xueqiu-scraper) — stock posts + user timelines
- [JD.com Scraper](https://apify.com/zhorex/jd-scraper) — JD product detail extraction

If you need single-platform deep scraping (full comment trees, user profile enrichment, infinite scroll, comment threads), use the platform-specific actors directly. This aggregator is for cross-platform brand mention tracking with normalized output — Bilibili coverage is included only via this aggregator.

### Compliance posture

- Only public mentions — no private accounts, no DMs, no follower lists, no email scraping
- No login bypass; cookies are user-supplied for higher rate limits only and stored as a secret in the input schema (encrypted at rest by Apify)
- Reviewer / commenter nicknames are partially redacted by the source platforms; this Actor passes through what the platforms display — no additional PII enrichment
- Residential proxy support for compliance with platform fair-use norms

### Integrations & data export

The Actor integrates with your existing workflow tools:

- **Google Sheets** — Send scraped mentions directly to a spreadsheet
- **Slack** — Webhook on completed runs, or filter to alert on negative-sentiment KOL mentions
- **Zapier / Make / n8n** — Trigger downstream workflows on new mentions
- **REST API** — Call the actor programmatically from any language
- **Webhooks** — Get notified when a scheduled run finishes
- **Data formats** — Download as JSON, CSV, Excel, XML, or RSS

### Roadmap

- Chinese BERT sentiment model (replaces lexicon for higher accuracy on nuanced cases)
- Per-mention English translation field (drop your DeepL / Google Translate cost)
- Webhook / streaming output (push mentions as they're scraped instead of batched)
- Douyin (TikTok China) coverage — under evaluation
- Expanded brand-match modes (regex, fuzzy, multi-keyword OR)

### Support

Found a bug or want a new field? [Open an issue on the Actor page](https://apify.com/zhorex/chinese-brand-monitor/issues) — typical turnaround within 48 hours.

***

💡 **Found this Actor useful?** Please [leave a star rating](https://apify.com/zhorex/chinese-brand-monitor/reviews) — it helps other Chinese-market teams discover this tool instead of paying $50K/year for a Synthesio seat. 30 seconds, one click.

***

*Last updated: May 2026 · Actively maintained · Trusted by brand monitoring agencies, DTC brands entering China, China-watcher hedge funds, and AI training data teams.*

# Actor input Schema

## `brandKeyword` (type: `string`):

Brand name in Chinese or English. Accepts both — e.g. '李宁', 'Li-Ning', 'Apple', '耐克', 'NIKE'. For best recall on bilingual brands, run twice (once per language) and merge.

## `platforms` (type: `array`):

Subset of platforms to query. Default: all five. Disabling platforms lowers cost and runtime.

## `maxMentionsPerPlatform` (type: `integer`):

Hard cap on mentions returned per platform. Controls cost and runtime.

## `lookbackDays` (type: `integer`):

Recency filter. Applied per platform on a best-effort basis — some platforms don't expose a server-side date filter (we discard older mentions client-side).

## `sentimentAnalysis` (type: `boolean`):

Run lexicon-based Chinese sentiment scoring on each mention. Adds polarity (positive/neutral/negative) and a -1.0…+1.0 score. Disable to reduce runtime by ~5%.

## `deduplication` (type: `boolean`):

Detect near-duplicate brand mentions reposted across platforms within 24h. Duplicates are merged into the canonical mention's crossPlatformReposts array. Billed only on canonical records.

## `cookieStrings` (type: `object`):

Optional cookie strings keyed by platform name (weibo / bilibili / rednote / douban / xueqiu). Unlocks higher recall and rate limits where supported. Format: paste the raw Cookie header value from your browser's DevTools. Not required — the actor degrades gracefully when omitted.

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

Apify proxy configuration. RESIDENTIAL with CN country is recommended for the highest recall and lowest rate-limit risk.

## Actor input object example

```json
{
  "brandKeyword": "李宁",
  "platforms": [
    "weibo",
    "bilibili",
    "rednote",
    "douban",
    "xueqiu"
  ],
  "maxMentionsPerPlatform": 100,
  "lookbackDays": 7,
  "sentimentAnalysis": true,
  "deduplication": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CN"
  }
}
```

# 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 = {
    "brandKeyword": "李宁",
    "platforms": [
        "weibo",
        "bilibili",
        "rednote",
        "douban",
        "xueqiu"
    ],
    "maxMentionsPerPlatform": 100,
    "lookbackDays": 7
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/chinese-brand-monitor").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 = {
    "brandKeyword": "李宁",
    "platforms": [
        "weibo",
        "bilibili",
        "rednote",
        "douban",
        "xueqiu",
    ],
    "maxMentionsPerPlatform": 100,
    "lookbackDays": 7,
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/chinese-brand-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "brandKeyword": "李宁",
  "platforms": [
    "weibo",
    "bilibili",
    "rednote",
    "douban",
    "xueqiu"
  ],
  "maxMentionsPerPlatform": 100,
  "lookbackDays": 7
}' |
apify call zhorex/chinese-brand-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zhorex/chinese-brand-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chinese Brand Monitor: Weibo + RedNote + Bilibili Aggregator",
        "description": "Track brand mentions across China's top 5 social/content platforms in a single call. Normalized output, sentiment-tagged, cross-platform deduplicated. Enterprise-grade coverage at $0.045/mention. Built for brand monitoring agencies, DTC e-commerce, China-watcher funds.",
        "version": "0.5",
        "x-build-id": "zB6fOk6YJM0NHAXos"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~chinese-brand-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-chinese-brand-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/zhorex~chinese-brand-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-chinese-brand-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/zhorex~chinese-brand-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-chinese-brand-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "brandKeyword"
                ],
                "properties": {
                    "brandKeyword": {
                        "title": "Brand keyword",
                        "type": "string",
                        "description": "Brand name in Chinese or English. Accepts both — e.g. '李宁', 'Li-Ning', 'Apple', '耐克', 'NIKE'. For best recall on bilingual brands, run twice (once per language) and merge."
                    },
                    "platforms": {
                        "title": "Platforms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Subset of platforms to query. Default: all five. Disabling platforms lowers cost and runtime.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "weibo",
                                "bilibili",
                                "rednote",
                                "douban",
                                "xueqiu"
                            ],
                            "enumTitles": [
                                "Weibo (微博) — microblog",
                                "Bilibili (B站) — video",
                                "RedNote (小红书 / Xiaohongshu) — lifestyle",
                                "Douban (豆瓣) — reviews & groups",
                                "Xueqiu (雪球) — stock/cashtag sentiment"
                            ]
                        },
                        "default": [
                            "weibo",
                            "bilibili",
                            "rednote",
                            "douban",
                            "xueqiu"
                        ]
                    },
                    "maxMentionsPerPlatform": {
                        "title": "Max mentions per platform",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on mentions returned per platform. Controls cost and runtime.",
                        "default": 100
                    },
                    "lookbackDays": {
                        "title": "Lookback window (days)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Recency filter. Applied per platform on a best-effort basis — some platforms don't expose a server-side date filter (we discard older mentions client-side).",
                        "default": 7
                    },
                    "sentimentAnalysis": {
                        "title": "Sentiment analysis",
                        "type": "boolean",
                        "description": "Run lexicon-based Chinese sentiment scoring on each mention. Adds polarity (positive/neutral/negative) and a -1.0…+1.0 score. Disable to reduce runtime by ~5%.",
                        "default": true
                    },
                    "deduplication": {
                        "title": "Cross-platform deduplication",
                        "type": "boolean",
                        "description": "Detect near-duplicate brand mentions reposted across platforms within 24h. Duplicates are merged into the canonical mention's crossPlatformReposts array. Billed only on canonical records.",
                        "default": true
                    },
                    "cookieStrings": {
                        "title": "Per-platform cookies (optional)",
                        "type": "object",
                        "description": "Optional cookie strings keyed by platform name (weibo / bilibili / rednote / douban / xueqiu). Unlocks higher recall and rate limits where supported. Format: paste the raw Cookie header value from your browser's DevTools. Not required — the actor degrades gracefully when omitted."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. RESIDENTIAL with CN country is recommended for the highest recall and lowest rate-limit risk.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "CN"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```