# RedNote Xiaohongshu Scraper: Little Red Book Notes (`moggedhq/rednote-xiaohongshu-scraper`) Actor

Get RedNote (Xiaohongshu) feed notes or full notes from share links with likes, saves, tags, creator names, images and video URLs. About $0.0049 per note: 20 notes cost $0.098. No login. Choose full details for text and counts; keyword search and comment threads are unavailable.

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

## Pricing

from $3.92 / 1,000 notes

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

## RedNote Xiaohongshu Scraper: Little Red Book Notes

For brand analysts, agencies and researchers collecting public RedNote feed notes or checking a known list of note links. About **$0.0049 per delivered note**: 20 notes cost $0.098, plus the $0.00005 platform start charge. Full details have no additional note fee. Paid Apify plans receive the tier discounts shown in Pricing.

Collect recommendation and lifestyle feeds, or supply current note share links for complete text, engagement and media. No Xiaohongshu account, exported account cookies or QR login is needed.

**Scope:** keyword search and comment threads are unavailable in this signed-out page route. Choose a channel or paste note links. The fast default returns clearly labelled **feed previews**. Turn on `includeDetails` for full note pages. A note supplied by link always requests full details. Both modes cost the same amount per delivered note, so choose full details when you need the additional fields.

### What you get

| Field | Feed preview | Full note |
| --- | --- | --- |
| `verdict` | Plain description of the preview | Confirmation that the full public note was read |
| `type` | `note` | `note` |
| `noteId`, `title` | Public ID and title | Public ID and title |
| `text` | `null` | Complete body supplied by the page |
| `noteType` | Image or video, when supplied | Source note format |
| `likes` | Feed like count | Note-page like count |
| `collects` | `null` | Save count when shown |
| `commentsCount` | `null` | Comment count when shown |
| `shares` | `null` | Share count when shown |
| `tags` | Empty list; tags were not read | Topic names on the note page |
| `authorId`, `authorNickname` | Public creator ID and display name | Public creator ID and display name |
| `authorFollowers` | Usually `null` | Filled only when a matching public profile was also read |
| `publishedAt` | `null` | UTC publication time from the source |
| `ipLocation` | Usually `null` | Coarse source location label when shown |
| `images` | Available cover | Available gallery URLs |
| `videoUrl` | `null` | Available playable stream URL |
| `url` | Source note link with share token | Resolved public note link |
| `scrapedAt` | Observation time in UTC | Observation time in UTC |
| `dataLevel` | `preview` | `full` |
| `source` | Input feed or link | Input feed or link |
| `countsMayBeRounded` | Source count abbreviation flag | Source count abbreviation flag |

Missing values stay `null`; real zeros stay zero. An abbreviated count such as `1.2万` becomes 12,000 and is flagged as potentially rounded. Media are returned as links, not downloaded files.

The dataset also contains free `NOTICE`, `creator` and `SUMMARY` rows. Filter on `type == "note"` for note records only. A creator row contains public profile metadata and is not a billable note. The summary is also saved as the separate `SUMMARY` key-value record.

### Three steps to your first result

1. Keep `channels` at `["recommend"]`, `maxItems` at 20 and `includeDetails` off for a quick public feed preview.
2. Start the Actor. Inspect the dataset's Overview view for titles, likes, creators and note links. The Content view groups text and media.
3. For complete text, turn on `includeDetails`, or paste selected note URLs into `startUrls` and clear `channels`.

A measured run on 29 October 2026 returned 20 unique previews in **15.0 seconds**. A separate full-details run returned 20 complete notes in **72.8 seconds**. Runtime varies with source response time, redirects and retries. Full mode reads each individual note page. The release acceptance matrix returned the expected notes across 30 varied cloud inputs, and ten notes were checked against fresh public pages. A real reboot test confirmed no duplicate notes or second charges.

### Inputs

| Input | Default | Meaning |
| --- | --- | --- |
| `channels` | Recommendation feed when no links or searches are supplied | Public lifestyle channels, listed below. Clear for link-only jobs. |
| `startUrls` | Empty | Full note URLs, app share URLs, public creator profiles or desktop feed URLs. Use current note tokens. |
| `maxItems` | `20` | Global maximum unique notes across all inputs, 0 to 1,000. Free rows do not use this limit. |
| `includeDetails` | `false` | Read full pages for feed notes. Direct note links always request full details. |
| `noteType` | `all` | `all`, `image` or `video`; filters the collected public sample. |
| `sort` | `general` | Preserve source order, or save a separate sample sorted by `popular` or `newest`. |
| `proxyConfiguration` | Automatic | Datacenter, a fresh session, then China residential after refusal. Custom settings are accepted. |
| `searchTerms` | Empty | Compatibility input; signed-out keyword search returns a free notice. |
| `includeComments` | `false` | Compatibility input; true returns a free explanation that threads are unavailable. |
| `maxCommentsPerNote` | `20` | Reserved compatibility field; no comment extraction or fee is enabled. |

Channels: `recommend`, `food`, `fashion`, `beauty`, `movies`, `career`, `relationships`, `home`, `gaming`, `travel`, `fitness`.

Channels are source selections, not arbitrary keyword searches. Choosing `food` does not request every note mentioning food. Non-recommendation channels may serve older selections. Inspect `publishedAt` in full mode when recency matters.

#### Fast feed previews

```json
{
  "channels": ["recommend"],
  "maxItems": 20,
  "includeDetails": false
}
```

#### Complete notes from a channel

```json
{
  "channels": ["food"],
  "maxItems": 10,
  "includeDetails": true,
  "noteType": "all"
}
```

#### A known list of note links

Replace these placeholders with the real note ID and its matching current source token:

```json
{
  "channels": [],
  "startUrls": [
    "https://www.xiaohongshu.com/explore/NOTE_ID?xsec_token=CURRENT_TOKEN&xsec_source=pc_feed"
  ],
  "maxItems": 20
}
```

Both `/explore/<id>` and `/discovery/item/<id>` are accepted, together with `xhslink.com` and `xhslink.cn` share hosts. A bare note ID does not provide a working token. Tokens come from the source and can expire; this Actor never invents them. An unavailable link produces a free notice and is not replaced with another note.

To collect videos, add `"noteType": "video"`. Filters can reduce matches per page. A thematic feed with a fixed selection may have fewer notes than the maximum. Collection stops when enough unique notes have been found or the available sample is exhausted.

### Reading and sorting results

Every note starts with `verdict`. `dataLevel` makes its depth explicit. Preview rows support discovery and triage; full rows support text analysis and engagement monitoring. Preview nulls do not mean zero saves, zero shares or an empty body.

The Summary reports notes, full notes, previews, comments, distinct creators, top tags, top creators, unavailable details, duplicate exclusions and spending-limit status. Tags are counted from full pages actually read. Preview-only runs have an empty top-tags list. Creator rankings describe the collected sample, not the whole platform.

`sort: "popular"` saves `SORTED-NOTES` by observed likes; `"newest"` sorts it by available publication time. The dataset retains serial delivery order for restart recovery. Sorting covers only the collected sample and does not apply platform search ranking or discover a historical catalogue. Use full details for meaningful publication dates.

### Example from a live run

Selected fields from a full-note run on 29 October 2026. The actual row also contains the full body, creator, tags and media.

```json
{
  "verdict": "Full public note retrieved.",
  "type": "note",
  "noteId": "6a978307000000002b0279b4",
  "title": "冷色调就显得很高级实况图",
  "noteType": "image",
  "likes": 18000,
  "collects": 13000,
  "commentsCount": 56,
  "shares": 2584,
  "publishedAt": "2026-09-02T01:59:35Z",
  "dataLevel": "full"
}
```

### Monitor notes every day

Save a task containing your current note URLs and schedule it in Apify Console. Each run reads fresh public pages. Join exports by `noteId` to compare likes, saves, comments and shares over time. The Actor does not calculate historical changes itself.

For discovery, schedule a recommendation-feed task. Its sample changes and can contain previously seen notes. Deduplication applies within one run, including across repeated links and channels. A later run is a new observation and can charge for the same note again. Maintain your own historical ID set if you need cross-run exclusion.

Webhooks can notify n8n, Make or Zapier when a run succeeds. Export JSON, JSONL, CSV or Excel, or load the dataset into a spreadsheet or database. Retain `type` and `dataLevel` downstream so notices and previews remain distinguishable from full notes.

### Pricing and limits

| Delivered notes | List-price note charge |
| --- | --- |
| 1 | $0.0049 |
| 20 | $0.098 |
| 100 | $0.49 |
| 1,000 | $4.90 |

Add the $0.00005 minimum platform start charge. Bronze receives 5% off note charges, Silver 10%, and Gold and higher tiers 20%. The final charge is the plan price shown in Apify. Full details have no extra fee; previews are also delivered notes at the selected plan price.

Duplicates, unavailable notes, retries, creator metadata, notices, summaries and empty results have no note charge. There is no automatic fee for every dataset row. If a full-note request fails, its preview is not substituted or charged.

Use `maxItems` for a note limit and Apify's maximum run charge for a money ceiling. The Actor checks the remaining note budget before delivery and stops when another note cannot be charged. A restarted run recovers saved rows and reconciles acknowledged charges before continuing. Completed notes are not fetched, delivered or charged again merely because the container restarted.

### API examples

Use your own Apify token in the environment. Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("moggedhq/rednote-xiaohongshu-scraper").call(
    run_input={"channels": ["recommend"], "maxItems": 20}
)
notes = [row for row in client.dataset(run["defaultDatasetId"]).iterate_items()
         if row.get("type") == "note"]
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('moggedhq/rednote-xiaohongshu-scraper').call({
  channels: ['recommend'], maxItems: 20, includeDetails: false
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const notes = items.filter(row => row.type === 'note');
```

curl:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~rednote-xiaohongshu-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"channels":["recommend"],"maxItems":20,"includeDetails":false}'
```

For larger full-detail jobs, start an asynchronous run and fetch its dataset after completion. A long synchronous request can time out while the Actor continues successfully.

### Use with AI agents (MCP)

An agent connected to `https://mcp.apify.com` can use the same JSON input. Ask it to collect public feed notes or read complete current share URLs. For text analysis, request `includeDetails: true`. It should inspect `dataLevel`, `SUMMARY` and free notices before analysing results.

Example request: Collect ten full public notes from the food channel, retain source links and publication dates, and summarise the topics in the notes actually retrieved. Keyword search is outside this Actor's supported route. A successful run containing a search-unavailable notice is not a successful keyword extraction.

### FAQ and honest limits

**Keyword search?** Unavailable signed out. The compatibility field gives a free notice. Use feed channels or note links.

**Comment threads?** Unavailable. Full notes can include comment counts, but no comment text, replies or commenter profiles are collected or charged.

**Creator profiles?** Public profile metadata is tried and returned free. The source can require a fresh profile link, limit access by IP or hide grid note IDs. Hidden IDs are not reconstructed; supply complete note share links for individual posts.

**Permanent media?** No. Source-signed image and video links expire. Download content you are permitted to retain promptly. A media link does not grant redistribution rights.

**My account?** The Actor accepts no account cookies or login tokens, performs no login and solves no CAPTCHA. It keeps only anonymous session information set by its own source visits.

**Source refusals?** A fresh session is tried and the automatic route can fall back to China residential. Persistent refusal becomes a free notice. Review the summary as well as run status.

RedNote, Xiaohongshu, XHS and Little Red Book refer to the source platform. This independent tool is not affiliated with or endorsed by it. Use public content in accordance with source terms and applicable rights.

# Actor input Schema

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

Choose recommend, food, fashion, beauty, movies, career, relationships, home, gaming, travel or fitness. Other channels can contain older selections. Leave empty when supplying only note links.

## `startUrls` (type: `array`):

Full public note share URLs including xsec_token, creator profile links or /explore?channel_id= links. Note links always request full details. Profile metadata is free; hidden profile-grid note IDs are skipped.

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

Global maximum unique note rows across every input. Unavailable notes, notices, creators and summaries do not count.

## `includeDetails` (type: `boolean`):

Read each note page for full text, saves, comment count, shares, tags, publish time and media. Slower: about 3 seconds per extra request. No extra note charge. OFF returns clearly labelled feed previews with title, likes, creator and cover.

## `noteType` (type: `string`):

Filter the public sample to image or video notes.

## `sort` (type: `string`):

general preserves source order. newest/popular writes a free SORTED-NOTES export for the collected sample; it does not change platform search ranking. Previews have no publish time.

## `includeComments` (type: `boolean`):

Compatibility field. Comment threads are unavailable in this public page route. TRUE gives a free notice. Full notes include comment counts when shown.

## `maxCommentsPerNote` (type: `integer`):

Reserved input. This build does not retrieve comment threads and never charges for comments.

## `searchTerms` (type: `array`):

Compatibility field. Search is unavailable signed out and produces a free notice. Choose public feed channels or supply complete note links for usable note output.

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

Default: datacenter, fresh-session retry, then China residential only after refusal. You may supply your own proxy settings. No account cookies or login tokens are accepted.

## Actor input object example

```json
{
  "channels": [
    "recommend"
  ],
  "maxItems": 20,
  "includeDetails": false,
  "noteType": "all",
  "sort": "general",
  "includeComments": false,
  "maxCommentsPerNote": 20
}
```

# Actor output Schema

## `notes` (type: `string`):

No description

## `content` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `sortedNotes` (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"
    ],
    "maxItems": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/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 = {
    "channels": ["recommend"],
    "maxItems": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/rednote-xiaohongshu-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"
  ],
  "maxItems": 20,
  "includeDetails": false
}' |
apify call moggedhq/rednote-xiaohongshu-scraper --silent --output-dataset

```

## MCP server setup

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