# Xiaohongshu RedNote Creator Tracker: Profiles, Posts, Comments (`neverempty/rednote-creator-tracker`) Actor

For brands, agencies and KOL research on Xiaohongshu (RedNote, 小红书): track creators in one Actor. Likes and saves totals, recent posts, post stats and comments. One run on 2026-10-14 returned 8 creators, 212 posts and 150 comments. Monitoring returns only new posts. No login. CSV or Excel.

- **URL**: https://apify.com/neverempty/rednote-creator-tracker.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.49 / 1,000 post returneds

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

## Xiaohongshu RedNote Creator Tracker: Profiles, Posts, Comments

**Track Xiaohongshu (小红书, RedNote) creators for brand monitoring, KOL vetting and agency reporting: each creator's exact likes and saves totals, follower band and post count, their recent posts, the full stats of any post from its share link, and comments with replies, exported to CSV, Excel or JSON.** Turn on monitoring and schedule it, and each run returns only the posts a creator published since the last run, so you see new KOL posts on RedNote without opening the app.

Built for brands watching the China market, influencer marketing agencies and researchers who shortlist Xiaohongshu KOLs, check campaign posts and follow competitors, all from one Actor with one input and no RedNote login.

### What you get in one run

- **Profiles**: nickname, RedNote ID (小红书号), bio, IP location shown on the profile, avatar, follower band (for example 10K+), following, **exact total likes and total saves**, likes + saves, number of posts.
- **Recent posts of each profile**: title, image or video, pinned or not, likes, publish date, cover image, position on the profile.
- **Full post details from a share link**: title, full text, hashtags, mentions, publish and last-edit time, likes, saves, comments, shares, all image URLs, the video URL and length, and the author.
- **Comments with replies**: comment text, likes, date, IP location, whether it is pinned or written by the post author, reply count, and replies as their own rows linked to their parent comment.
- **Monitoring**: schedule the Actor and get only new posts from each profile. The first run is free.

One run on 2026-10-14 returned 8 creator profiles, 204 of their recent posts, 8 full posts from share links and 150 comments and replies.

Every row has a `type` column (`profile`, `profile-post`, `post`, `comment`), so one dataset filters cleanly into four tables.

### Why this Actor

- **One Actor instead of four.** Profiles, profile posts, post details and comments come from the same run and the same input, with the same column names.
- **Input names you already know.** The fields follow the most used social media scrapers on Apify: `profiles`, `resultsPerPage`, `postURLs`, `excludePinnedPosts`, `oldestPostDateUnified`, `newestPostDate`, `commentsPerPost`, `maxRepliesPerComment`.
- **Honest numbers.** RedNote shows large counts rounded (8.5万 = 85,000). Those values are returned as numbers and listed in `countsRounded`, with the original text in `countsText`, so you always know which numbers are exact.
- **Pay only for rows you get.** Missing posts, invalid links and anything RedNote did not show come back as free rows of type `note` that say why.

### How to use it

1. Put RedNote profile links (or 24-character user IDs, or xhslink.com share links) in **Profiles**.
2. Put post share links in **Direct URLs of posts** (copy them with RedNote's Share button; they contain `xsec_token=`), or xhslink.com short links.
3. Choose **Number of posts per profile**, an optional date range, and **Maximum comments per post** if you want comments.
4. Run, then download CSV, Excel or JSON, or connect the dataset to Google Sheets, Zapier or Make.

Example input:

```json
{
    "profiles": ["https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a"],
    "resultsPerPage": 10,
    "postURLs": ["https://www.xiaohongshu.com/explore/6a6ff733000000000503030c?xsec_token=YOUR_TOKEN&xsec_source=pc_share"],
    "commentsPerPost": 20,
    "maxRepliesPerComment": 3,
    "oldestPostDateUnified": "30 days"
}
```

### Input fields

| Field | What it does |
|---|---|
| `profiles` | Profile links, 24-character user IDs or xhslink.com links. One profile row each, plus its posts. |
| `resultsPerPage` | Posts to return per profile (0 = profile row only). |
| `postURLs` | Post share links or xhslink.com links. One full post row each. |
| `excludePinnedPosts` | Skip posts pinned to the top of a profile. |
| `oldestPostDateUnified` | Only posts published on or after this date (`2026-01-31` or `30 days`). |
| `newestPostDate` | Only posts published on or before this date. |
| `commentsPerPost` | Comments to return per post in `postURLs` (0 = none). |
| `maxRepliesPerComment` | Replies to return under each top-level comment. |
| `monitoringMode` | Return only posts that are new on each profile since the last run. |
| `resetMonitoringState` | Forget what monitoring remembered. |
| `useProxy` | Retry through another connection when RedNote does not answer. |

### Output example

A post row (values shortened):

```json
{
    "type": "post",
    "id": "6a6ff733000000000503030c",
    "url": "https://www.xiaohongshu.com/explore/6a6ff733000000000503030c?xsec_token=...",
    "postType": "video",
    "title": "Example title",
    "text": "Example text #example",
    "hashtags": ["example"],
    "createTime": "2026-08-03T02:04:35.000Z",
    "likeCount": 100000,
    "collectCount": 43000,
    "commentCount": 722,
    "shareCount": 4204,
    "countsText": { "likeCount": "10万+", "collectCount": "4.3万", "commentCount": "722", "shareCount": "4204" },
    "countsRounded": ["likeCount", "collectCount"],
    "videoUrl": "https://sns-video-zl.xhscdn.com/stream/....mp4",
    "videoDurationSeconds": 17,
    "imageUrls": ["https://sns-webpic-qc.xhscdn.com/..."],
    "authorId": "5c9074e00000000016036d0a",
    "authorNickname": "Example creator"
}
```

A profile row:

```json
{
    "type": "profile",
    "id": "5c9074e00000000016036d0a",
    "nickname": "Example creator",
    "redId": "100000001",
    "followerCountText": "1万+",
    "followerCountAtLeast": 10000,
    "likeCount": 267625,
    "collectCount": 62129,
    "likesAndCollects": 329754,
    "postCount": 55,
    "ipLocation": "Zhejiang"
}
```

### Monitoring new posts

Turn on `monitoringMode` and schedule the Actor (for example every hour). The first run remembers the posts each profile lists now and is free. Every later run returns only posts that were not there before. When a profile has nothing new, you pay one check for it. Posts that could not be delivered because of your spending limit are not marked as seen, so they come in the next run.

### Pricing

Pay per result. Prices per 1,000 on the Apify Free plan; paid Apify plans pay less.

| Result | Price per 1,000 |
|---|---|
| Profile row (`profile-returned`) | $8.99 |
| Full post from a share link (`post-returned`) | $8.99 |
| Post listed on a profile (`profile-post-returned`) | $3.99 |
| Comment or reply (`comment-returned`) | $4.99 |
| Monitoring check with nothing new (`source-checked`) | $6.99 |

Rows of type `note` (explanations) are free.

### FAQ

**How do I get the follower count and total likes of a Xiaohongshu creator?**
Put the profile link in `profiles`. The profile row has total likes, total saves, likes + saves and the number of posts as exact numbers, and the follower band RedNote shows publicly (for example 1万+ = 10,000 or more).

**How do I export the likes, saves and comments of a RedNote post?**
Copy the post's share link and put it in `postURLs`. The post row has likes, saves, comments and shares, the text, hashtags, images and the video URL.

**How can I get RedNote comments into CSV or Excel?**
Add the post share links to `postURLs` and set `commentsPerPost`. Each comment is a row; replies are rows with `isReply` and `parentCommentId`.

**How do I get notified when a Xiaohongshu creator posts?**
Turn on `monitoringMode`, schedule the Actor, and connect the run to email, Slack or a webhook. Each run returns only new posts.

**Is RedNote the same as Xiaohongshu?**
Yes. Xiaohongshu (小红书, also called Little Red Book) is the Chinese name of the app and RedNote is its English name. Links from xiaohongshu.com and xhslink.com both work.

**How do I compare several Xiaohongshu KOLs at once?**
Put all their profile links in `profiles`. Each creator gets a profile row and their recent posts in the same dataset, so one run gives you one table to compare likes, saves, post counts and posting dates.

**Can I use this as a Xiaohongshu (RedNote) API?**
Yes. Start runs and read the results as JSON through the Apify API or the Python and JavaScript clients, and use schedules and webhooks to feed your own dashboard.

**Do I need a RedNote account or cookies?**
No. The Actor reads what RedNote shows to visitors who are not logged in.

### Good to know

- RedNote shows visitors about 30 recent posts per profile, and those listings carry no post ID, so `profile-post` rows have `id` and `url` empty. To get the full details of a post, use its share link in `postURLs`.
- RedNote shows visitors a follower band (for example 1万+) rather than the exact follower count. It is returned as `followerCountText` and `followerCountAtLeast`; `followerCount` is filled only when RedNote shows an exact number.
- Comments: RedNote shows visitors the first page of comments of a post, about 10 top-level comments with their first replies. When there are more, a free `more-need-login` row says so.
- Post links need the `xsec_token` part (it is in every link copied with the Share button). A link without it comes back as a free `share-link-needed` row.
- Keyword search on RedNote requires a login, so this Actor does not search by keyword.
- Contact details in bios, posts and comments (email, phone, WeChat, QQ) are replaced with a marker.
- Unofficial. Public data only. Not affiliated with Xiaohongshu.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

## `profiles` (type: `array`):

RedNote (Xiaohongshu) profiles to read: profile links like https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a, the 24-character user ID, or an xhslink.com share link. Each gives one profile row plus its recent posts. Leave empty if you only use postURLs.

## `resultsPerPage` (type: `integer`):

How many of each profile's listed posts to return (newest first as RedNote lists them). 0 returns only the profile row. RedNote lists about 30 recent posts per profile to visitors.

## `postURLs` (type: `array`):

Posts to read in full: the share link copied from RedNote (it contains xsec_token=) or an xhslink.com short link. Each gives one post row with all counts, text, hashtags, images and video URL. Leave empty if you only use profiles.

## `excludePinnedPosts` (type: `boolean`):

Skip the posts a creator pinned to the top of the profile (they are often old). Off by default.

## `oldestPostDateUnified` (type: `string`):

Return only posts published on or after this date. Use 2026-01-31, or a relative value like 30 days. Empty means no lower limit.

## `newestPostDate` (type: `string`):

Return only posts published on or before this date (2026-01-31 includes that whole day, UTC). Empty means no upper limit.

## `commentsPerPost` (type: `integer`):

For each post in Direct URLs of posts, return up to this many comments (top-level comments and their replies counted together). 0 skips comments. RedNote shows visitors the first page of comments, about 10 top-level comments with their first replies.

## `maxRepliesPerComment` (type: `integer`):

How many of the replies RedNote shows under each top-level comment to return as their own rows (marked isReply with parentCommentId). 0 returns top-level comments only.

## `monitoringMode` (type: `boolean`):

Run on a schedule and get only the posts that appeared on each profile since the last run. The first run only remembers what is listed now and is free; later runs with nothing new cost one check per profile. Profile rows are not repeated in this mode. Direct URLs of posts are read as usual.

## `resetMonitoringState` (type: `boolean`):

Forget what monitoring remembered, so the next monitoring run starts over. Use once, then turn off.

## `useProxy` (type: `boolean`):

If RedNote does not answer or redirects to its login page, try once more through Apify's residential connection. Off means direct connection only.

## Actor input object example

```json
{
  "profiles": [
    "https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a"
  ],
  "resultsPerPage": 10,
  "excludePinnedPosts": false,
  "commentsPerPost": 0,
  "maxRepliesPerComment": 0,
  "monitoringMode": false,
  "resetMonitoringState": false,
  "useProxy": true
}
```

# Actor output Schema

## `results` (type: `string`):

Rows of four types, marked in the type column: profile (follower band, exact likes and saves totals, post count, bio, IP location), profile-post (each recent post listed on a profile with likes and date), post (full post from a share link: title, text, hashtags, likes, saves, comments, shares, date, image and video URLs) and comment (text, likes, date, IP location, replies marked with their parent). In monitoring mode only the new posts of each profile are returned. Invalid input, missing posts and verification pages come back as free rows of type note that say why.

# 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 = {
    "profiles": [
        "https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a"
    ],
    "resultsPerPage": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/rednote-creator-tracker").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 = {
    "profiles": ["https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a"],
    "resultsPerPage": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("neverempty/rednote-creator-tracker").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 '{
  "profiles": [
    "https://www.xiaohongshu.com/user/profile/5c9074e00000000016036d0a"
  ],
  "resultsPerPage": 10
}' |
apify call neverempty/rednote-creator-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/rednote-creator-tracker"
        }
    }
}
```

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/HDgRoeoXboMIMd8ev/builds/pzOfsDseTtOTHfkau/openapi.json