# Xiaohongshu (RedNote) Trending Discovery Scraper (`foxlabs/xiaohongshu-trending-scraper`) Actor

Discover what is trending on Xiaohongshu (RedNote) right now — no login, no account, no cookies.

- **URL**: https://apify.com/foxlabs/xiaohongshu-trending-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 trending notes

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/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

## Xiaohongshu (RedNote) Trending Discovery Scraper

Discover **what is trending on Xiaohongshu (小红书 / RedNote) right now** — the notes, creators and topics rising across the app's home-feed channels — with **no login, no account, no cookies and no Chinese phone number**.

### 🔥 What is it — and when should you use it?

RedNote's home feed is where Chinese consumer trends surface first: beauty, fashion, food, travel, gadgets. This Actor reads that live trending feed and returns a clean, de-duplicated list of trending notes with their creators and like counts — so you can **monitor what is taking off on RedNote** without a login, an account pool, or fragile anti-bot games. Use it for trend research, content ideation, creator discovery and competitive monitoring.

It is a **discovery** tool. It does **not** scrape note full text, comments, user profiles or keyword search — those sit behind RedNote's login wall, and this Actor deliberately stays on the keyless surface instead of pretending to reach them.

### 🤖 Use with AI agents

The Actor is **pay-per-event** and built to be agent-friendly: one simple input, one clean output row per note, and a machine-readable result. Point any MCP-enabled assistant (Claude, ChatGPT, Cursor) at it once it is on the Apify MCP server, or call it directly via the Apify API. Billing is per delivered note, so an agent pays only for what it collects; runs that deliver nothing are free.

### 📋 Overview

| | |
|---|---|
| **Source** | xiaohongshu.com home-feed (`/explore`) server-rendered trending state |
| **Auth** | None — no login, cookie, account or Chinese phone |
| **Method** | Pure HTTP over residential CN/HK proxy (no browser) |
| **Output** | One row per unique trending note |
| **Billing** | Pay per delivered unique note |

### ✨ Features

- 🔓 **Keyless** — no login, no account, no cookies, no SMS/QR.
- 🔁 **Deep, deduplicated sweep** — the feed refreshes each request; the Actor rounds over your channels and dedupes by note id (measured: 1,000 notes, 0 duplicates).
- 📈 **Real engagement** — like counts parsed from `6.9万` to `69000`, original text kept (measured median ≈ 7,600 likes).
- 🎛️ **Channel control** — pick Fashion, Food, Cosmetics, Travel, Gaming and more, or sweep all.
- 🧱 **Reliable** — rotates a fresh residential exit per request; a single blocked exit is retried, not fatal.
- 🧭 **Honest scope** — never returns empty "content" columns it cannot fill.

### 🎬 Quick Start

```json
{ "channels": ["fashion", "food", "cosmetics"], "maxResults": 1000, "country": "CN" }
```

### 🚀 Getting Started (3 steps)

1. Pick one or more **Channels** (or leave empty for all).
2. Set **Max results** (unique notes) and keep **Residential proxy** on.
3. Run — notes stream into the dataset as they are found.

### 📥 Input

| Field | Type | Description |
|---|---|---|
| `channels` | array | `recommend`, `fashion`, `food`, `cosmetics`, `movie_tv`, `career`, `emotion`, `gaming`, `travel`, `fitness`, `video`. Empty = all. |
| `maxResults` | integer | Hard cap on unique notes. Default `1000`. |
| `maxRounds` | integer | Max sweeps of the channel list. Default `40`. |
| `country` | string | Residential exit: `CN` or `HK`. Default `CN`. |
| `maxRunSeconds` | integer | Optional soft time budget (0 = none). |
| `proxyConfiguration` | object | Residential proxy (required). |

### 📤 Output

```json
{
  "noteId": "6a73f636000000002402ffdf",
  "url": "https://www.xiaohongshu.com/explore/6a73f636000000002402ffdf?xsec_token=ABQY...",
  "title": "刚刚，张雅琪中餐厅海报被删",
  "type": "normal",
  "channel": "recommend",
  "authorName": "刚刚！",
  "authorId": "61d1710a0000000010008b8b",
  "likedCount": 1634,
  "likedCountText": "1634",
  "cover": "http://sns-webpic-qc.xhscdn.com/...!nc_n_webp_mw_1",
  "xsecToken": "ABQY...",
  "scrapedAt": "2026-10-28T04:01:43.720Z"
}
```

Download the dataset as JSON, CSV, Excel or HTML.

### 🧱 Data table

| Field | Description |
|---|---|
| `noteId` | Note id (unique key). |
| `url` | Direct note URL (with access token). |
| `title` | Note title. |
| `type` | `normal` or `video`. |
| `channel` | Trending channel it came from. |
| `authorName` / `authorId` / `authorAvatar` | The creator. |
| `likedCount` | Likes as an integer. |
| `likedCountText` | Likes exactly as RedNote shows them. |
| `cover` | Cover image URL. |
| `scrapedAt` | Collection time (ISO). |

### 🧠 How it works

RedNote server-renders the live home feed into the page's own state blob. The Actor fetches `/explore` (and `/explore?channel_type=…`) over a residential CN/HK proxy, brace-matches that state, and reads the feed array. No browser, no cookie, no login request. The login-gated API (search / note detail / comments) is never contacted.

### 🧪 Data quality — measured

Measured on a 1,000-note run (11 channels, 2026-10-28, run `0xYzmuqWEDwWpytNA`):

- **Uniqueness:** 1,000 / 1,000 notes unique (0 duplicates).
- **Field fill:** author 100%, likes 100%, cover 100%, title 99.7%.
- **Meaningful engagement:** like count median ≈ 7,572; 946 of 1,000 notes have ≥ 1,000 likes; none have 0 — these are genuinely trending notes.
- **Diversity:** 948 distinct creators; 54% image notes, 46% video.

### ⏱️ Performance — measured

Same run: **1,000 unique notes in 194 seconds**, 4 sweeps, 0 blocked exits, 0 read failures. The feed refreshes each request, so repeated sweeps keep surfacing new notes until your cap or the feed stops producing new ones.

### 💼 Use cases

- **Trend monitoring** — track what is rising on RedNote daily per category.
- **Content ideation** — mine high-engagement titles and formats.
- **Creator discovery** — find creators behind trending notes.
- **Competitive / market research** — watch a category's momentum over time.

### 🔗 Integration

Schedule it, connect it to Make / Zapier / n8n, or call the Apify API and push notes into a sheet, warehouse or dashboard. Each run's summary is written to the `SOURCE_REPORT` key-value record.

### 📊 Pricing

**Pay per delivered unique note.** A run that delivers nothing is not charged. See the Actor's pricing panel for the current per-note rate. Collecting 1,000 trending notes is a single, inexpensive run.

### ❓ FAQ

#### Does it need my RedNote (Xiaohongshu) login or cookies?

No. It never logs in and never asks you for an account, cookie or proxy of your own. You pick which trending channels to pull and run.

#### What does each trending note row contain?

`title`, `type`, `cover`, the `channel` it trended in, the author (`authorName`, `authorId`), the like count (`likedCount` and `likedCountText`), the `noteId`, the `url` and `scrapedAt`.

#### Which channels can I pull, and how many notes?

The trending `channels` RedNote publishes. `maxResults` and `maxRounds` bound the run; because the feed reshuffles, extra rounds surface more unique notes.

#### Can it get a note's full text, comments, or do keyword search?

No. Those are login-gated and out of scope by design. The Actor focuses on the public trending feeds and never fakes data it cannot read.

#### Should I use a CN or HK proxy?

Both work. Switch between them with the `country` option if one exit is slow or blocked.

#### How current is the data?

Every run reads RedNote live, so the trending notes and like counts reflect what the platform shows at run time. Schedule it to track trending movement over time.

#### Why is a field null?

RedNote did not carry it for that note. A missing value is always null, never a placeholder or a guess.

#### How is billing calculated?

Pay per result: you are charged only for trending notes actually returned, never for an empty run or an error.

#### Can I export to CSV, Excel or JSON?

Yes. Download the dataset as JSON, CSV or Excel from the Apify console, or pull it from the Apify API or the dataset's `.json` endpoint for a dashboard or an AI agent.

#### Is it legal to collect this data?

It reads publicly visible RedNote trending feeds, with no login. Use the output in line with applicable laws and the platform's terms; see the legal note below.

### 🐛 Troubleshooting

- **A run returned nothing:** the residential exit may have hit a login page — just run again (the exit rotates), or switch `country`.
- **Fewer notes than expected:** raise `maxResults` / `maxRounds` or add channels.

### 🚧 What it does not do

Note full text, comments, user-profile details and keyword search are **not** provided — they require RedNote's login-gated API. This Actor is for trending **discovery** and will not return empty columns it cannot fill.

### ⚖️ Is it legal to scrape RedNote trending data?

The Actor reads only publicly served, non-personal trending data that RedNote renders to any visitor. Use the data in line with RedNote's terms and applicable law; do not use it to store personal data without a lawful basis.

### 🤝 Support & contact

Questions or a custom need (another channel, a different field)? Open an issue on the Actor's Issues tab.

### Changelog

See `CHANGELOG.md`.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/xiaohongshu-trending-scraper/changelog.md

# Actor input Schema

## `channels` (type: `array`):

Which trending channels to pull from. Leave empty for all. Each channel is a RedNote home-feed category.

## `maxResults` (type: `integer`):

Hard cap on delivered trending notes (deduplicated by note id across the whole run). The feed refreshes on every request, so a sweep keeps bringing new notes until this cap or no new ones appear.

## `maxRounds` (type: `integer`):

How many times to loop over the selected channels at most. Each sweep returns a freshly refreshed feed. The run stops early when it reaches Max results or a whole sweep brings no new notes.

## `country` (type: `string`):

Residential exit country. Both work; try the other if one is slow or blocked.

## `maxRunSeconds` (type: `integer`):

Optional soft deadline. The run stops sweeping after this many seconds even if Max results is not reached. 0 means no time limit (only Max results / Max rounds apply).

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

Residential proxy is required (RedNote serves the trending state to residential IPs). Defaults to Apify Residential in the selected country.

## Actor input object example

```json
{
  "channels": [
    "recommend",
    "fashion",
    "food",
    "cosmetics"
  ],
  "maxResults": 1000,
  "maxRounds": 40,
  "country": "CN",
  "maxRunSeconds": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `sourceReport` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channels": [
        "recommend",
        "fashion",
        "food",
        "cosmetics"
    ],
    "maxResults": 1000,
    "maxRounds": 40,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/xiaohongshu-trending-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 = {
    "channels": [
        "recommend",
        "fashion",
        "food",
        "cosmetics",
    ],
    "maxResults": 1000,
    "maxRounds": 40,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/xiaohongshu-trending-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 '{
  "channels": [
    "recommend",
    "fashion",
    "food",
    "cosmetics"
  ],
  "maxResults": 1000,
  "maxRounds": 40,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call foxlabs/xiaohongshu-trending-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/xiaohongshu-trending-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/b1fUq2wkdy5AqEfYi/builds/8bvVtMKLFQSz2U4rc/openapi.json