# RedNote (Xiaohongshu) Scraper - Trending Notes & Creators (`scrapesage/rednote-xiaohongshu-scraper`) Actor

Scrape RedNote / Xiaohongshu with no login or cookies: trending notes across 12 category feeds, full note detail (body, all images, video stream URLs, likes/collects/comments/shares as real numbers) and creator profiles with RedID, IP location, followers, engagement rate. Monitor-only-new mode.

- **URL**: https://apify.com/scrapesage/rednote-xiaohongshu-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, Videos, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 note scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<!--
BUILD RECEIPT (internal, not customer-facing)
Demand receipt (2026-07-21 APAC recon, _ops/reports/2026-07-21-apac-demand-recon.md):
Xiaohongshu / RedNote = ~4,489 total users / ~2,487 monthly users across Apify Store competitors
- the single largest live APAC pool measured. Ranked #3 in the Tier-A build list.
Wedge (recon says win on coverage + price, NOT reliability): every incumbent depends on a
logged-in cookie/session for keyword search; this actor is 100% anonymous SSR, so it cannot
break when a cookie expires - and it ships engagement counts as parsed integers plus author
RedID / IP-location / follower enrichment on every note, which no incumbent does.
Weakest incumbent measured: zen-studio/rednote-user-profile-scraper 84% success (196u/153mo).
Built 2026-07-22 under an explicit in-session backlog override from Luke.
-->

## RedNote (Xiaohongshu) Scraper - Trending Notes & Creators

Scrape **RedNote / Xiaohongshu (小红书)** without a login, without cookies, and without a headless browser. Pull **what is trending right now** across 12 category feeds, the **full detail of any note** (complete body text, every gallery image, playable video stream URLs, and the whole engagement breakdown), and **rich creator profiles** with the **RedID handle, IP location, follower count and engagement rate**.

**No account. No cookie string. No CAPTCHA solving.** Everything this actor reads is server-rendered public data, so there is no session to expire and nothing to re-authenticate when RedNote rotates its login.

### Why this RedNote scraper?

Most Xiaohongshu actors are built on a **logged-in session**: you paste a `web_session` cookie, or the actor keeps a shared account alive behind the scenes. That works until the cookie dies. This actor takes the anonymous path and invests the difference in **data density**.

| Data | Typical RedNote scrapers | This actor |
|---|---|---|
| Requires a login / cookie string | ⚠️ usually | ✅ never |
| Engagement as **real numbers** (`29000`) | ❌ raw `"2.9万"` text | ✅ parsed integers **and** original text |
| Combined **engagement total** per note | ❌ | ✅ |
| Author **RedID handle** on every note | ❌ | ✅ |
| Author **IP location** on every note | ❌ | ✅ (enriched from the profile) |
| Author **follower count** on every note | ❌ | ✅ |
| **All** gallery images + dimensions | partial | ✅ every image, W×H, live-photo flag |
| Video **stream URLs** + codecs | partial | ✅ master + backup URLs, h264/h265/h266/av1 |
| Topic tags & @-mentions | partial | ✅ both, with IDs |
| Creator **engagement rate** (avg likes ÷ followers) | ❌ | ✅ derived |
| Trending discovery across **12 category feeds** | ❌ mostly keyword-only | ✅ |
| Only-new **monitor mode** across scheduled runs | ❌ | ✅ |

### What you can scrape

Pick one of four modes:

| Mode | What it does |
|---|---|
| **Trending notes** | Sweeps the RedNote category feeds and returns the notes that are getting distribution right now, each with full detail. |
| **Note details** | Paste note links - get the complete record for each one. |
| **Creator profiles** | Paste profile links - get the full creator record plus their recent notes. |
| **Creator / KOL leads** | Discovers trending notes, then returns **one enriched creator record per unique author** - a ready-made KOL prospect list. |

### Use cases

- **KOL / influencer discovery** - build a shortlist of Xiaohongshu creators who are *currently* getting reach, with follower counts, engagement rate, IP location and their RedID handle for outreach.
- **China & cross-border market research** - track what is trending in beauty, fashion, food, travel and home, with engagement you can actually sort and chart.
- **Brand & competitor monitoring** - schedule the actor in monitor mode and receive only newly surfaced notes mentioning your categories.
- **Content & creative research** - pull full body text, hashtags and the entire image gallery for swipe files and creative analysis.
- **Trend datasets for AI** - clean, structured, deduplicated note records with numeric engagement, ready for analysis or model training.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) - the free plan is enough to try this actor.
2. Open the **RedNote (Xiaohongshu) Scraper**, leave the defaults (trending, Recommended feed, 50 notes) and click **Start**.
3. Watch records stream into the dataset table.
4. **Export** as JSON, CSV, Excel or XML - or pull results via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "trending",
    "channels": ["recommend", "homefeed.cosmetics_v3"],
    "maxItems": 100,
    "enrichNoteDetails": true,
    "includeAuthorProfile": true,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

- **mode** - `trending`, `notes`, `creators`, or `creatorLeads`.
- **channels** - which feeds to sweep: Recommended (homepage), Fashion, Beauty, Food, Travel, Fitness, Home & living, Career, Relationships, Film & TV, Gaming, Video.
- **noteUrls** - note links for `notes` mode. **Keep the `xsec_token` parameter** that RedNote puts in every share link - Xiaohongshu requires it to open a note.
- **creatorUrls** - profile links for `creators` mode.
- **maxItems** - result cap (`0` = unlimited; the run still stops safely before its timeout).
- **enrichNoteDetails** - open every note for the full record (on by default).
- **includeAuthorProfile** - add the author's RedID, IP location and follower count to every note (on by default).
- **monitorMode** / **monitorStoreName** - emit only records not seen in previous runs.
- **concurrency** - parallel requests (lower it if you see empty results).
- **proxyConfiguration** - RESIDENTIAL is the default and the most reliable.

### Output

One note record (trimmed):

```json
{
    "type": "note",
    "noteId": "64a81034000000002b03f3c5",
    "url": "https://www.xiaohongshu.com/explore/64a81034000000002b03f3c5?xsec_token=...",
    "noteType": "normal",
    "title": "女孩子不一定要局限于一个风格",
    "description": "夏天的漂亮衣服真的好多呀～...",
    "publishedAt": "2023-07-07T13:16:36.000Z",
    "likes": 9287,
    "collects": 5531,
    "comments": 339,
    "shares": 666,
    "engagementTotal": 15823,
    "likesText": "9287",
    "authorId": "58fac5da50c4b4155bab85c9",
    "authorName": "佛山靓爆镜",
    "authorRedId": "94742130489",
    "authorIpLocation": "广东",
    "authorFollowers": 10000,
    "authorUrl": "https://www.xiaohongshu.com/user/profile/58fac5da50c4b4155bab85c9",
    "topics": ["穿搭", "夏日穿搭"],
    "mentions": [],
    "coverUrl": "https://sns-webpic-qc.xhscdn.com/...",
    "imageCount": 16,
    "images": [{ "url": "...", "width": 1438, "height": 1920, "livePhoto": false }],
    "videoUrl": null,
    "discoveredVia": "recommend",
    "scrapedAt": "2026-07-22T13:07:41.902Z"
}
```

One creator record (trimmed):

```json
{
    "type": "creator",
    "userId": "5e632f6d0000000001006f42",
    "redId": "LiliAndT",
    "nickname": "dearClaire",
    "bio": "...",
    "gender": "female",
    "ipLocation": "法国",
    "followers": 10000,
    "following": 10,
    "likesAndCollects": 10000,
    "avgLikesPerNote": 1841,
    "engagementRate": 18.41,
    "listedNoteCount": 31,
    "recentNotes": [{ "noteId": "...", "title": "...", "likes": 2300, "url": "..." }],
    "url": "https://www.xiaohongshu.com/user/profile/5e632f6d0000000001006f42"
}
```

### Notes on coverage (honest limits)

- **Engagement counts** are published by Xiaohongshu in abbreviated form (`2.9万`, `1千+`). This actor returns **both** a parsed integer and the original string. Where RedNote itself only publishes a rounded band (`1万+`), the integer is that band's value - it is a floor, not an exact count.
- **`ipLocation` is not present on note pages** at all - it exists only on profile pages. That is why it is enriched onto notes from the author's profile (keep `includeAuthorProfile` on).
- **Video fields are populated for video notes only**; image notes have no video, by definition.
- **Keyword search and comment threads are not included.** Xiaohongshu gates both behind a logged-in session, and this actor is deliberately login-free. If you need those, a cookie-based actor is the right tool - this one trades that surface for never breaking on an expired session.
- Xiaohongshu **rate-limits repeated requests from one IP**. The actor rotates proxy sessions automatically and returns partial data with a status message rather than failing. If a run comes back light, re-run it.

### Pricing

Pay per result, no start fee:

| Event | Price |
|---|---|
| Note scraped | **$0.004** |
| Creator profile | **$0.010** |

### Integrations

Connect this actor to [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://apify.com/integrations/slack), [Google Drive](https://apify.com/integrations/google-drive), [Airbyte](https://apify.com/integrations/airbyte), [GitHub](https://apify.com/integrations/github), or anything else via [webhooks](https://docs.apify.com/platform/integrations/webhooks) and the [Apify API](https://docs.apify.com/api/v2). Run it on a [schedule](https://docs.apify.com/platform/schedules) with monitor mode for a continuous trend feed.

### Use with AI assistants (MCP)

This actor is available through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), so Claude, ChatGPT, Cursor and other MCP clients can call it directly as a tool - ask your assistant for "trending RedNote beauty creators" and it can run this scraper and read the results.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More social & ad-intelligence scrapers

- [TikTok Scraper](https://apify.com/scrapesage/tiktok-scraper)
- [TikTok Ad Library Scraper](https://apify.com/scrapesage/tiktok-ad-library-scraper)
- [YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)
- [Twitter Scraper](https://apify.com/scrapesage/twitter-scraper)
- [Reddit Scraper](https://apify.com/scrapesage/reddit-scraper)
- [Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)
- [LinkedIn Ad Library Scraper](https://apify.com/scrapesage/linkedin-ad-library-scraper)
- [Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)
- [Google Play Scraper](https://apify.com/scrapesage/google-play-scraper)

### Legal

This actor collects **publicly available** data that Xiaohongshu serves to anonymous visitors. It performs no login, bypasses no access control, and collects no private or personal-account data. You are responsible for using the output in line with Xiaohongshu's terms and with applicable data-protection law (including GDPR/PIPL where relevant) - in particular, have a lawful basis before using creator data for outreach.

# Actor input Schema

## `mode` (type: `string`):

trending = sweep the RedNote category feeds for what is performing right now. notes = full detail for note URLs you paste. creators = full profile for creator URLs you paste. creatorLeads = discover trending notes, then return one enriched creator record per unique author (KOL lead list).

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

Which RedNote feeds to sweep in 'trending' and 'creatorLeads' modes. 'Recommended' is the main homepage feed and is the most reliable. Ignored for the URL-based modes.

## `noteUrls` (type: `array`):

Used when mode = 'Note details'. Paste RedNote note links (share links or /explore/... links). Keep the xsec\_token query parameter that RedNote puts in the link - Xiaohongshu requires it to open a note. A bare 24-character note ID also works if you have a matching token.

## `creatorUrls` (type: `array`):

Used when mode = 'Creator profiles'. Paste RedNote profile links such as https://www.xiaohongshu.com/user/profile/<id>?xsec\_token=... Keep the xsec\_token if the link has one.

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

Maximum records to return. Set 0 for unlimited (the run still stops safely before its timeout).

## `enrichNoteDetails` (type: `boolean`):

ON (recommended): open every note for the full body text, every image, video stream URLs, topics and the complete engagement breakdown. OFF: return only the lightweight feed card (title, cover, likes) - faster, but a much thinner dataset.

## `includeAuthorProfile` (type: `boolean`):

Adds the author's RedID handle, IP location and follower count to every note. One extra request per unique author, cached across the run.

## `maxNotesPerCreator` (type: `integer`):

How many of a creator's own notes to include in their record (RedNote profile pages list about 30).

## `concurrency` (type: `integer`):

Parallel requests. Lower this if you see empty results - Xiaohongshu throttles bursts from one IP.

## `monitorMode` (type: `boolean`):

Remember what previous runs returned and emit only records that have not been seen before. Ideal on a schedule for tracking new trending content or newly surfaced creators.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the seen-IDs state for monitor mode. Use a different name per tracked topic to keep their histories separate.

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

Xiaohongshu rate-limits repeated requests from a single IP, so a proxy is strongly recommended. RESIDENTIAL is the most reliable group.

## Actor input object example

```json
{
  "mode": "trending",
  "channels": [
    "recommend"
  ],
  "noteUrls": [],
  "creatorUrls": [],
  "maxItems": 50,
  "enrichNoteDetails": true,
  "includeAuthorProfile": true,
  "maxNotesPerCreator": 30,
  "concurrency": 8,
  "monitorMode": false,
  "monitorStoreName": "rednote-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped RedNote note and creator records as JSON items in the default dataset.

# 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 = {
    "mode": "trending",
    "channels": [
        "recommend"
    ],
    "noteUrls": [],
    "creatorUrls": [],
    "maxItems": 50,
    "enrichNoteDetails": true,
    "includeAuthorProfile": true,
    "maxNotesPerCreator": 30,
    "concurrency": 8,
    "monitorMode": false,
    "monitorStoreName": "rednote-monitor",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/rednote-xiaohongshu-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 = {
    "mode": "trending",
    "channels": ["recommend"],
    "noteUrls": [],
    "creatorUrls": [],
    "maxItems": 50,
    "enrichNoteDetails": True,
    "includeAuthorProfile": True,
    "maxNotesPerCreator": 30,
    "concurrency": 8,
    "monitorMode": False,
    "monitorStoreName": "rednote-monitor",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/rednote-xiaohongshu-scraper").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 '{
  "mode": "trending",
  "channels": [
    "recommend"
  ],
  "noteUrls": [],
  "creatorUrls": [],
  "maxItems": 50,
  "enrichNoteDetails": true,
  "includeAuthorProfile": true,
  "maxNotesPerCreator": 30,
  "concurrency": 8,
  "monitorMode": false,
  "monitorStoreName": "rednote-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapesage/rednote-xiaohongshu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/rednote-xiaohongshu-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote (Xiaohongshu) Scraper - Trending Notes & Creators",
        "description": "Scrape RedNote / Xiaohongshu with no login or cookies: trending notes across 12 category feeds, full note detail (body, all images, video stream URLs, likes/collects/comments/shares as real numbers) and creator profiles with RedID, IP location, followers, engagement rate. Monitor-only-new mode.",
        "version": "0.1",
        "x-build-id": "CuyFiLLcCu9ZmHZMp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~rednote-xiaohongshu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-rednote-xiaohongshu-scraper",
                "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/scrapesage~rednote-xiaohongshu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-rednote-xiaohongshu-scraper",
                "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/scrapesage~rednote-xiaohongshu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-rednote-xiaohongshu-scraper",
                "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",
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "trending",
                            "notes",
                            "creators",
                            "creatorLeads"
                        ],
                        "type": "string",
                        "description": "trending = sweep the RedNote category feeds for what is performing right now. notes = full detail for note URLs you paste. creators = full profile for creator URLs you paste. creatorLeads = discover trending notes, then return one enriched creator record per unique author (KOL lead list).",
                        "default": "trending"
                    },
                    "channels": {
                        "title": "Category feeds",
                        "type": "array",
                        "description": "Which RedNote feeds to sweep in 'trending' and 'creatorLeads' modes. 'Recommended' is the main homepage feed and is the most reliable. Ignored for the URL-based modes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "recommend",
                                "homefeed.fashion_v3",
                                "homefeed.cosmetics_v3",
                                "homefeed.food_v3",
                                "homefeed.travel_v3",
                                "homefeed.fitness_v3",
                                "homefeed.household_product_v3",
                                "homefeed.career_v3",
                                "homefeed.love_v3",
                                "homefeed.movie_and_tv_v3",
                                "homefeed.gaming_v3",
                                "homefeed.video_v3"
                            ],
                            "enumTitles": [
                                "Recommended (homepage feed)",
                                "Fashion / outfits",
                                "Beauty / makeup",
                                "Food",
                                "Travel",
                                "Fitness",
                                "Home & living",
                                "Career",
                                "Relationships",
                                "Film & TV",
                                "Gaming",
                                "Video"
                            ]
                        },
                        "default": [
                            "recommend"
                        ]
                    },
                    "noteUrls": {
                        "title": "Note URLs or IDs",
                        "type": "array",
                        "description": "Used when mode = 'Note details'. Paste RedNote note links (share links or /explore/... links). Keep the xsec_token query parameter that RedNote puts in the link - Xiaohongshu requires it to open a note. A bare 24-character note ID also works if you have a matching token.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "creatorUrls": {
                        "title": "Creator profile URLs or IDs",
                        "type": "array",
                        "description": "Used when mode = 'Creator profiles'. Paste RedNote profile links such as https://www.xiaohongshu.com/user/profile/<id>?xsec_token=... Keep the xsec_token if the link has one.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to return. Set 0 for unlimited (the run still stops safely before its timeout).",
                        "default": 50
                    },
                    "enrichNoteDetails": {
                        "title": "Fetch full note detail",
                        "type": "boolean",
                        "description": "ON (recommended): open every note for the full body text, every image, video stream URLs, topics and the complete engagement breakdown. OFF: return only the lightweight feed card (title, cover, likes) - faster, but a much thinner dataset.",
                        "default": true
                    },
                    "includeAuthorProfile": {
                        "title": "Enrich notes with author profile",
                        "type": "boolean",
                        "description": "Adds the author's RedID handle, IP location and follower count to every note. One extra request per unique author, cached across the run.",
                        "default": true
                    },
                    "maxNotesPerCreator": {
                        "title": "Max notes listed per creator",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many of a creator's own notes to include in their record (RedNote profile pages list about 30).",
                        "default": 30
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel requests. Lower this if you see empty results - Xiaohongshu throttles bursts from one IP.",
                        "default": 8
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new)",
                        "type": "boolean",
                        "description": "Remember what previous runs returned and emit only records that have not been seen before. Ideal on a schedule for tracking new trending content or newly surfaced creators.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store that holds the seen-IDs state for monitor mode. Use a different name per tracked topic to keep their histories separate.",
                        "default": "rednote-monitor"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Xiaohongshu rate-limits repeated requests from a single IP, so a proxy is strongly recommended. RESIDENTIAL is the most reliable group.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
