# Xiaohongshu Scraper \[$2.50/1K💰] | RedNote Notes | Comments (`ahmed_jasarevic/xiaohongshu-fast-scraper`) Actor

Scrape Xiaohongshu (RedNote) notes, creators and comments: likes, collects, shares, tags and IP location. Search keywords or category feeds, export to JSON or CSV.

- **URL**: https://apify.com/ahmed_jasarevic/xiaohongshu-fast-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 results

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) Scraper – Notes, Creators & Comments

Extract **Xiaohongshu / RedNote** data: note text, images, video URLs, tags, engagement counts (likes, collects, comments, shares), author profiles and comments. Search keywords, open note or profile URLs, or sweep the 11 category feeds. **$2.50 per 1,000 notes.**

### What Can You Do With Xiaohongshu Data?

- **Creator discovery** – find accounts gaining traction in fashion, food, travel, beauty, fitness or gaming
- **Content research** – analyse titles, tags and formats that perform in a category
- **Campaign benchmarking** – compare engagement rates across notes and creators before booking a collaboration
- **Trend spotting** – sweep the category feeds daily and see which topics keep appearing
- **Hashtag and keyword tracking** – follow a topic across search results and note pages
- **Comment analysis** – pull top-level comments for sentiment, product mentions or objections

### How It Works

![How the Xiaohongshu Scraper works: from a search or feed to note records with engagement and comments.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-xiaohongshu-fast-scraper.webp)

The Actor collects publicly available Xiaohongshu / RedNote note, creator and comment data and normalizes it into one schema. Provide note or profile URLs, keywords or category feeds; it reads the published pages and writes one record per note or creator.

- Keyword search returns notes in pages up to `maxSearchPages`.
- `includeNoteDetails` adds description, images, video URL and tags.
- `includeComments` attaches top-level comments.
- Category feeds broaden discovery beyond direct URLs.

### Scrape Xiaohongshu Notes And Creator Data

This Actor focuses on the public note and creator data that Xiaohongshu publishes, so runs stay fast and lightweight. It returns a stable schema from publicly visible data.

The trade-off is scope: search and comment coverage can vary by note and target. Direct note and profile URLs are the most reliable targets; large runs can use an Apify proxy.

### Search Notes, Sweep Category Feeds Or Open Profiles

`searchQueries` accepts Chinese keywords and returns 20 notes per page up to `maxSearchPages` (default 10, so about 200 notes per keyword at most). `sort` picks general, latest or popular ordering, and `noteType` filters video versus image notes.

`feedCategories` controls the Explore sweep — all 11 feeds are selected by default (recommend, fashion, food, travel, cosmetics, movie & TV, career, love, household, gaming, fitness). Category feeds are processed in parallel; `feedConcurrency` trades speed for reliability.

`startUrls` is the surgical option: paste note URLs, creator profile URLs, explore/search URLs or bare note ids, and only those targets are scraped.

### Engagement Metrics And Creator Fields

Notes carry an `interact` object with numeric `likes`, `collects`, `comments` and `shares`, plus `publishedAt`, `lastUpdatedAt` and `ipLocation`. The `author` object holds `userId`, `nickname`, `avatar` and profile URL.

Creator targets produce a separate record shape in the `creators` dataset view: `userId`, `nickname`, `redId`, `fansCount`, `postedCount`, `likesAndCollects`, `ipLocation` and `url` — enough to rank accounts without opening each profile by hand.

### Input – Configure A Xiaohongshu Run

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | `[]` | Note URLs, profile URLs, explore/search URLs or 24-char note ids |
| `searchQueries` | array | No | `[]` | Chinese keywords; search availability can vary |
| `maxNotes` | integer | No | `100` | Max note records; `0` = unlimited |
| `includeNoteDetails` | boolean | No | `true` | Full description, images, video, tags — separate paid event |
| `includeComments` | boolean | No | `true` | Attach top-level comments — separate paid event |
| `maxCommentsPerNote` | integer | No | `10` | Top-level comments per note |
| `sort` | string | No | `general` | `general`, `latest`, `popular` |
| `noteType` | string | No | `all` | `all`, `video`, `image` |
| `maxSearchPages` | integer | No | `10` | Search pages per keyword, 20 notes each |
| `feedCategories` | array | No | 11 feeds | Category feeds used for Explore/homefeed targets |
| `feedConcurrency` | integer | No | `3` | Parallel feed operations. Lower values keep runs reliable |
| `proxyConfiguration` | object | No | none | Standard Apify proxy configuration. Recommended for large runs |
| `requestDelayMillis` | integer | No | `500` | Delay between operations |

### Output – Note And Creator Fields

Notes (default dataset view `overview`):

| Field | Type | Description |
|---|---|---|
| `type` | string | `note` or `user` |
| `noteId` | string | 24-character note id |
| `title`, `description` | string | Note text |
| `authorNickname` | string | Author nickname |
| `author` | object | `userId`, `nickname`, `avatar`, profile URL |
| `noteType` | string | Normal, video, image |
| `images` | array | Image URL, width, height |
| `video` | object | Best MP4 stream, duration, dimensions, cover |
| `tags`, `mentions` | array | Topics and mentioned users |
| `likeCount`, `collectCount`, `commentCount`, `shareCount` | number | Engagement counts |
| `publishedAt`, `lastUpdatedAt` | string | ISO timestamps |
| `ipLocation` | string | Author IP location shown by Xiaohongshu |
| `comments` | array | Top-level comments with author and likes |
| `url` | string | Public note URL |

Creators (dataset view `creators`): `type`, `userId`, `nickname`, `redId`, `fansCount`, `postedCount`, `likesAndCollects`, `ipLocation`, `url`.

### Example Input – One Keyword Plus A Creator Profile

```json
{
  "searchQueries": ["咖啡"],
  "startUrls": ["https://www.xiaohongshu.com/user/profile/5d37ebe30000000016006032"],
  "maxNotes": 60,
  "maxSearchPages": 3,
  "includeNoteDetails": true,
  "includeComments": true,
  "maxCommentsPerNote": 10,
  "sort": "popular"
}
```

### Example Output – One Note Record

```json
{
  "type": "note",
  "noteId": "6ab343fa000000001301b8c0",
  "title": "A day in Shanghai",
  "authorNickname": "Example creator",
  "noteType": "normal",
  "likeCount": 6896,
  "collectCount": 747,
  "commentCount": 948,
  "shareCount": 1954,
  "publishedAt": "2026-10-21T08:12:00.000Z",
  "ipLocation": "Shanghai",
  "url": "https://www.xiaohongshu.com/explore/6ab343fa000000001301b8c0"
}
```

### Export RedNote Data To JSON, CSV Or Excel And Schedule Runs

Results land in the default dataset and download as JSON, CSV, Excel or HTML. A 100-note run completes in a minute or two.

Creator metrics and trends move daily, so a **daily schedule** with `includeNoteDetails: false` is a cheap monitoring loop; add details and comments only when you need the text. At $0.0025 per note, $0.0015 per detail and $0.002 per comment batch, a default run with all three events costs about $0.006 per note.

### Related Actors

- [Google Search Scraper](https://apify.com/apify/google-search-scraper) – cross-check a creator or brand outside Xiaohongshu
- [Website Content Crawler](https://apify.com/apify/website-content-crawler) – pull linked brand and shop pages into clean text
- [Google Maps Scraper](https://apify.com/apify/google-maps-scraper) – verify the physical businesses behind beauty, food or travel notes
- [Blocket.se Scraper](https://apify.com/ahmed_jasarevic/blocket-se-scraper) – second-hand marketplace data for resale and product research

### FAQ

#### Why use this Actor instead of a general-purpose web scraper?

This Actor collects the public note and creator data directly, which keeps runs fast and lightweight.

#### Do I need a Xiaohongshu account?

No for notes, profiles and feeds. Search availability can vary; if search returns nothing, note and profile URLs still work. Comment coverage also varies by note and target.

#### Why are comments sometimes missing?

Because comment coverage varies by note and access level. An Apify proxy can improve coverage for large runs; without one, expect partial comment sets. Comments are also billed as a separate event, so leave `includeComments` off when you only need notes.

#### What does a run cost?

Three events can apply per note: the dataset row at $0.0025, `note-detail` at $0.0015 and `comments` at $0.002. With defaults all three are on, so a 1,000-note run is roughly $6. Turn details or comments off to reduce it.

#### How many notes can I get per keyword?

20 notes per search page, and `maxSearchPages` defaults to 10 — about 200 notes per keyword. Category feeds typically yield 100–160 unique notes per run.

#### Is this official Xiaohongshu data?

No. It is public data collected from Xiaohongshu. Xiaohongshu does not offer a public research API, and this Actor is not affiliated with the platform.

#### What are alternatives for RedNote data?

Commercial China-social vendors sell curated datasets, and general web scrapers exist on the Apify Store. This Actor is the lightweight option: faster, cheaper per run, with the same public fields.

### For AI Agents & LLM Apps

Returns one row per Xiaohongshu note (or creator) with engagement counts, author identity, media URLs and optional comments.

Minimal working input:

```json
{ "startUrls": ["6ab343fa000000001301b8c0"], "maxNotes": 1 }
```

Variant — keyword sweep without detail or comment charges:

```json
{ "searchQueries": ["咖啡"], "maxNotes": 40, "maxSearchPages": 2, "includeNoteDetails": false, "includeComments": false }
```

Output fields: `type, noteId, title, authorNickname, noteType, likeCount, collectCount, commentCount, shareCount, publishedAt, url, source` — plus `description, author, images, video, tags, mentions, ipLocation, comments` and the `creators` view (`userId, nickname, redId, fansCount, postedCount, likesAndCollects, ipLocation, url`).

Behaviors an agent should know:

- `includeNoteDetails` and `includeComments` both default to **true** and each triggers a separate billed event.
- Search availability can vary; if a search returns nothing, use note or profile URLs instead.
- `maxNotes` counts **notes only**; creator records are pushed separately and `0` means unlimited.
- `includeComments` costs $0.002 per note regardless of how many comments are visible; coverage varies by note and target.
- `feedCategories` only applies to Explore/homefeed targets, not to `searchQueries` or explicit note URLs.
- `feedConcurrency` above 3 can reduce reliability; lower it if runs start failing.
- `requestDelayMillis` (500 ms) is a throttle, not a guarantee — do not remove it on large runs.

Billing: **$0.0025 per note**, **$0.0015 per note detail**, **$0.002 per comment batch**, plus a small actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Xiaohongshu (RedNote) or its parent company.

It collects publicly visible notes, profiles and comments. No account credentials are harvested and no private accounts are accessed.

The output contains **personal data**: user ids, nicknames, avatars, IP-location labels and comment text. That data is subject to the platform's Terms of Service, China's Personal Information Protection Law (PIPL), and — where the data reaches EU or UK users — the GDPR. Do not use it for profiling, unsolicited outreach, or any purpose the platform's terms prohibit, and delete it when your research purpose is served. This section is a factual disclosure, not legal advice.

### SEO Keywords

xiaohongshu scraper, rednote scraper, xiaohongshu api, rednote api, xiaohongshu data, rednote notes, xiaohongshu creator data, rednote comments, xiaohongshu search, xiaohongshu followers, rednote engagement data, china social media data, xiaohongshu influencer data, rednote hashtag data, xiaohongshu dataset, xiaohongshu alternative, rednote analytics, china creator research

# Actor input Schema

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

Note URLs, creator profile URLs, explore/search URLs, or bare 24-character note IDs. Example note URL: https://www.xiaohongshu.com/explore/<noteId>?xsec_token=...

## `searchQueries` (type: `array`):

Keywords to search on Xiaohongshu. Works with the logged-in session built into the Actor; anonymous runs skip search with -104.

## `maxNotes` (type: `integer`):

Maximum number of note records to push to the dataset (0 = unlimited).

## `includeNoteDetails` (type: `boolean`):

Load each note page to collect the full description, image list, video URL, and tags. This option uses a separate paid note-detail event. Disable it for faster, cheaper card-only output.

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

Attach comments to note records. This option uses a separate paid comments event. Anonymous sessions usually receive only the first page for 1-2 notes per IP; a residential proxy extends coverage. Leave off for the fastest, cheapest runs.

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

Maximum number of top-level comments to collect per note.

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

Sort order for search results.

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

Filter search results by note type.

## `maxSearchPages` (type: `integer`):

Maximum number of search result pages to request per keyword (20 notes per page). Raise it when you need more results than about 100 per keyword.

## `feedCategories` (type: `array`):

Category feeds loaded for Explore/homefeed targets. Keep all selected for maximum coverage (typically 100-160 unique notes); each category needs its own anonymous guest session, so fewer categories run faster.

## `feedConcurrency` (type: `integer`):

Number of anonymous guest sessions bootstrapped in the background while the previous category is processed. 3 is the recommended default; 1 = fully sequential, 4 = fastest but more risk-control checks.

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

Optional proxy. Residential proxies are recommended for high-volume runs.

## `requestDelayMillis` (type: `integer`):

Delay between signed API calls to reduce risk-control challenges.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.xiaohongshu.com/explore"
    }
  ],
  "searchQueries": [],
  "maxNotes": 100,
  "includeNoteDetails": true,
  "includeComments": true,
  "maxCommentsPerNote": 10,
  "sort": "general",
  "noteType": "all",
  "maxSearchPages": 10,
  "feedCategories": [
    "homefeed_recommend",
    "homefeed.fashion_v3",
    "homefeed.food_v3",
    "homefeed.travel_v3",
    "homefeed.cosmetics_v3",
    "homefeed.movie_and_tv_v3",
    "homefeed.career_v3",
    "homefeed.love_v3",
    "homefeed.household_product_v3",
    "homefeed.gaming_v3",
    "homefeed.fitness_v3"
  ],
  "feedConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "requestDelayMillis": 500
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "startUrls": [
        {
            "url": "https://www.xiaohongshu.com/explore"
        }
    ],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/xiaohongshu-fast-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 = {
    "startUrls": [{ "url": "https://www.xiaohongshu.com/explore" }],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/xiaohongshu-fast-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 '{
  "startUrls": [
    {
      "url": "https://www.xiaohongshu.com/explore"
    }
  ],
  "searchQueries": []
}' |
apify call ahmed_jasarevic/xiaohongshu-fast-scraper --silent --output-dataset

```

## MCP server setup

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