I run a small portfolio of public scrapers on the Apify Store. Most of them are single-platform — one for Weibo, one for Douban, one for Xueqiu, one for RedNote (Xiaohongshu), and so on. They cover the long-tail of Chinese consumer signal that Synthesio and Brandwatch charge $50K/year+ for.

Then last week I spent 4 hours building a 6th actor — Chinese Brand Monitor — that doesn't scrape anything new. It just calls the same five platforms in parallel, normalizes the output, runs sentiment, and dedupes across platforms.

It launched at $0.045/mention — 9× the per-platform price of the single scrapers ($0.005/result). And on first impression buyers prefer it.

This post is about why that "aggregator pattern" works, the concrete shape of the code, and why I think it's the single highest-EV play available to indie Apify devs right now.

Why the aggregator commands a premium

The single-platform scrapers each do one thing well. But anyone monitoring a brand across China is never monitoring only one platform — they need at least Weibo + RedNote + Bilibili, often more. Without the aggregator, the buyer has to:

1. Run 5 separate Apify Actor calls
2. Parse 5 different output schemas (every platform has different field names, different time formats, different engagement metric coverage)
3. Reconcile cross-platform reposts (the same KOL post often appears across Weibo + RedNote within hours)
4. Run sentiment in their own pipeline
5. Push the joined record to their downstream BI / dashboard / alerting stack

I've talked to enough brand-monitoring agencies to know step 1-5 is a 4-6 hour engineering job per pipeline, plus ongoing maintenance every time a single-platform scraper output changes. The aggregator collapses that into a single API call with a stable normalized schema. The premium isn't for the data — it's for the orchestration the buyer doesn't have to write.

The shape of the actor

The whole thing is ~600 lines of Python. The input schema is brutally simple:

{
  "brandKeyword": "李宁",
  "platforms": ["weibo", "bilibili", "rednote", "douban", "xueqiu"],
  "maxMentionsPerPlatform": 100,
  "lookbackDays": 7,
  "sentimentAnalysis": true,
  "deduplication": true,
  "cookieStrings": { "weibo": "...", "xueqiu": "..." }
}

Architecture:

# main.py — the entire orchestration logic
tasks = []
for plat in platforms:
    fn = _SCRAPER_FNS[plat]
    cookie = (cookie_strings.get(plat) or "").strip()
    coro = fn(brand_keyword, max_results=max_per,
              lookback_days=lookback_days, cookie_string=cookie)
    tasks.append(with_timeout(coro, seconds=180,
                              label=f"{plat}.search", fallback=[]))

per_platform_results = await asyncio.gather(*tasks, return_exceptions=True)

raw_mentions = [m for plat_results in per_platform_results
                  if not isinstance(plat_results, Exception)
                  for m in plat_results]

if sentiment_on:
    _attach_sentiment(raw_mentions)
if dedup_on:
    canonical = deduplicate(raw_mentions)
else:
    canonical = raw_mentions

await Actor.push_data(canonical)
await Actor.charge(event_name="mention-aggregated", count=len(canonical))

Three production-grade details worth stealing:

1. Per-platform wall-clock budget. Each platform gets 180 seconds. If one platform is down or slow, the others still complete and the buyer still gets data. The with_timeout helper wraps asyncio.wait_for and returns an empty list on timeout — never raises, never breaks the gather.

2. Single billing event for the whole orchestration. I emit one mention-aggregated event per canonical record, billed at the aggregator's price. I do NOT use actor.call() to invoke the underlying single-platform actors as sub-runs — that would double-bill the buyer and shred margins. The scraper logic is re-implemented inline in the aggregator, sharing the same shape as the single-platform actors but billed once at the higher rate.

3. Pure-stdlib SimHash dedup. A common mistake is to skip dedup because adding a SimHash library feels heavy. SimHash is ~30 lines of stdlib code (md5 + bit hamming distance). For cross-platform reposts within a 24-hour window, a 12-bit Hamming threshold catches ~95% of duplicates and the canonical record gains a crossPlatformReposts: [...] array showing which platforms amplified it. Buyers love this field — it's the closest thing to a virality signal you can get from raw mention data.

The economics

Per-platform: 5 actors × $0.005/result × ~20 mentions/platform = $0.50 per "campaign monitoring pass"
Aggregator: 1 actor × $0.045/mention × 20-100 canonical records = $0.90-$4.50 per campaign pass

On the surface, the aggregator looks more expensive. It is — by design. But the buyer's actual cost comparison isn't "aggregator vs 5 raw actor calls." It's "aggregator vs (5 raw actor calls + 4-6 hours of joining, deduping, and sentiment pipeline work)."

At $100/hour for the engineer doing that work, the aggregator pays for itself on the first day of monitoring even at production volumes. At $200/hour (which is what most agencies bill for engineering time), it pays for itself in the first hour of work avoided.

I think this is the right premium. If anything I should test $0.060 — the aggregator's value-add vs the single-platform stack scales with how many platforms are involved, not linearly with how many mentions are pulled.

When does this pattern work?

It works when:

• You already own multiple complementary single-platform scrapers. Building the aggregator from scratch (without owning the underlying scrapers) means you're building 6 actors in the time of 1 — bad ROI. The leverage comes from reusing existing battle-tested platform clients.
• The buyer's natural use case spans multiple platforms. Brand monitoring, cross-platform sentiment, multi-marketplace product matching — all yes. Single-platform deep scraping (full comment trees, profile enrichment) — no, sell the single-platform actor for that.
• You can deliver a normalized output schema that's actually downstream-ready. This is the hard part. If your "normalized" output still requires the buyer to reshape it for their warehouse, you've just shifted the work, not eliminated it.

It doesn't work when:

• The single-platform scrapers have wildly different cost structures (e.g. one needs a paid LLM, another runs on free HTTP). The aggregator has to absorb the worst-case cost and your margin disappears.
• The platforms have such different output shapes that "normalizing" loses critical information.
• The aggregation logic itself is harder than buyers expect — if dedup, sentiment, and cross-language reconciliation push the actor past the 5-minute Apify Store auto-test budget, you'll spend more time on infrastructure than billing.

Why this is high-EV on Apify Store specifically

Apify Store has a discoverability cliff for new actors. The organic discovery loop (rank → installs → reviews → rank) takes 60-180 days for a fresh actor with zero existing presence. Buyers searching "Weibo scraper" find my Weibo scraper. Buyers searching "Chinese brand monitoring" — much smaller search volume, but much higher intent — find an aggregator that solves their actual problem in one call.

The aggregator inherits the proven scraping logic of the single-platform actors (so it's reliable from day 1) AND inherits zero of their accumulated discovery. That feels like a downside but it isn't: the aggregator targets a different keyword corpus (brand monitoring, China watch, cross-platform sentiment) that's barely contested vs the single-platform keyword space.

Plus, the cross-promo loop works both directions: every single-platform actor README now mentions the aggregator at the top (positioned as "if you need multi-platform"), and the aggregator README links back to the single-platform actors (positioned as "if you need deep single-platform scraping"). The combined SEO + discovery surface area is larger than the sum of the parts.

What I'd build next

The pattern generalizes. Specifically, I think the highest-EV next aggregator plays in scraper land are:

1. Cross-platform creator analytics — TikTok + YouTube Shorts + Instagram Reels + Twitch clips. Normalized output: creator handle, platform, follower count, recent engagement rate, content categories. Buyers: influencer agencies, brand-creator matchmaking platforms.
2. Multi-marketplace product price tracking — Amazon + eBay + Walmart + Target + Etsy + AliExpress for a single SKU. Normalized output: product title, price, currency, seller rating, in-stock status, shipping cost. Buyers: D2C brands monitoring their own listings + competitor pricing.
3. Cross-platform review aggregation — G2 + Capterra + TrustRadius for B2B software. Normalized output: product, platform, rating, review count, recent review text, sentiment. Buyers: B2B marketing teams running competitive intelligence.

If you're an indie Apify dev sitting on a portfolio of 3+ single-platform scrapers in the same vertical, the aggregator on top of them is the single most valuable hour of work you can do this quarter. Aggregators command premium pricing, attract higher-intent buyers, and create a discovery loop with your existing actors.

Built with Python + httpx + asyncio + a tiny pure-stdlib SimHash. Source on the Actor page. If you find this useful, a 30-second review on the actor page is the single biggest thing that helps me ship more.