RedNote (Xiaohongshu) Note Detail Scraper API

Extract structured details from public RedNote/Xiaohongshu notes—including video notes, image galleries, author data, engagement, tags, timestamps, covers, and downloadable video URLs.

Submit the complete public note URL with its matching xsec_token. This lets the Actor use the direct RedNote resolution path for reliable, lower-cost extraction.

Process 1–1,000 complete Xiaohongshu note URLs per run and receive one Dataset record for every submitted input, including clear failure and duplicate records.

Equivalent inputs are normalized to the same note identity, so canonical duplicates are resolved and billed only once. Successful records always include complete available note and media details; there are no output-control switches or separate video URL add-on.

Note details cost $6 per 1,000 successful notes at the standard rate, or as little as $3 per 1,000 with the lowest eligible Store rate.

✨ Key features

• Complete note details for research and automation — Return the note type, native title and description, author, engagement, tags, source timestamps, and scrape timestamp in predictable JSON.
• Video and image notes in one API — Use the same input and output workflow for Xiaohongshu video posts and multi-image galleries.
• Simple direct input — Submit complete public note URLs that already contain their matching token.
• Batch processing up to 1,000 inputs — Feed data pipelines, catalogs, dashboards, n8n, Make, Zapier, or API workflows with isolated per-input results.
• Duplicate-aware processing — Every submitted input receives a record, while canonical duplicate notes are resolved and billed only once.
• Complete media included — Receive image galleries and available video URLs and variants without a separate input switch or add-on charge.

🚀 Quick start

In Apify Console:

1. Add one or more complete public note URLs containing xsec_token to urls.
2. Confirm each URL token belongs to the same note.
3. Click Start.
4. Open the run's Dataset.
5. Read one structured result record for each submitted input.

Minimal input:

{
  "urls": ["https://www.xiaohongshu.com/explore/6a673660000000002201bdf0?xsec_token=ABpmxG_iiqv6i0PvH66YtPs66TX1rjAfCHs8s4EGoqXdk=&xsec_source=pc_search&source=web_explore_feed"]
}

Supported RedNote / Xiaohongshu inputs

The Actor accepts complete HTTP or HTTPS Xiaohongshu note URLs in these forms:

• https://www.xiaohongshu.com/explore/{noteId}?xsec_token=...
• https://www.xiaohongshu.com/discovery/item/{noteId}?xsec_token=...
• https://www.xiaohongshu.com/red_video/{noteId}?xsec_token=...

The Actor extracts the note ID and returns a canonical normalizedUrl in the form https://www.xiaohongshu.com/explore/{noteId}. Query parameters are not included in normalizedUrl.

Standalone note IDs, token-free URLs, short links, share text, profile pages, search pages, unrelated domains, and unsupported Xiaohongshu paths are rejected.

Note ID and required xsec_token

The note ID is the 24-character hexadecimal value after /explore/, /discovery/item/, or /red_video/ in the URL.

A valid xsec_token is required and must remain in the same URL as its note. Open the public note from Xiaohongshu search, feed, or sharing, then copy the complete browser URL; the token appears after ? or &. Keeping it in the URL improves direct-resolution reliability.

There is no separate run-level token field. Missing, expired, invalid, or mismatched tokens can cause validation or resolution failure. The token is not included in normalizedUrl.

Input

Field	Type	Required	Default	Limits	Description
urls	string[]	Yes	None	1–1,000 items	Complete supported note URLs containing a valid matching xsec_token. Values are normalized and deduplicated by canonical note identity.

Input examples

Single note:

{
  "urls": ["https://www.xiaohongshu.com/explore/6a673660000000002201bdf0?xsec_token=ABpmxG_iiqv6i0PvH66YtPs66TX1rjAfCHs8s4EGoqXdk=&xsec_source=pc_search&source=web_explore_feed"]
}

Batch input:

{
  "urls": [
    "https://www.xiaohongshu.com/explore/6428b7be000000001300d335?xsec_token=TOKEN_FOR_FIRST_NOTE",
    "https://www.xiaohongshu.com/explore/6a87dbad0000000005030ca4?xsec_token=TOKEN_FOR_SECOND_NOTE"
  ]
}

Short output example

{
  "input": "https://www.xiaohongshu.com/explore/6428b7be000000001300d335?xsec_token=...",
  "normalizedUrl": "https://www.xiaohongshu.com/explore/6428b7be000000001300d335",
  "success": true,
  "status": "success",
  "noteId": "6428b7be000000001300d335",
  "noteType": "image",
  "title": "Example note",
  "description": "Example description",
  "author": {
    "userId": "66ec990b000000001d031c8b",
    "nickname": "Example author",
    "profileUrl": "https://www.xiaohongshu.com/user/profile/66ec990b000000001d031c8b"
  },
  "engagement": { "likes": 123, "comments": 12, "collects": 45, "shares": 6 },
  "tags": [{ "id": "topic-id", "name": "Example topic" }],
  "images": [{ "index": 0, "url": "https://sns-webpic.example/image" }],
  "video": null,
  "scrapedAt": "2026-08-22T00:00:00.000Z"
}

Output

Every submitted input receives one Dataset record. Successful canonical inputs contain structured note details. Invalid, unsupported, inaccessible, missing, or unparseable inputs contain a safe error object instead. Duplicate inputs copy the canonical result and add duplicate and duplicateOf.

The Actor preserves source truth: missing optional fields are not invented, and an empty native title is never inferred from app share text. An original empty title is returned as "title": "".

RedNote/Xiaohongshu media URLs are normalized to HTTPS for recognized RedNote CDN hosts. They are still source CDN URLs and can expire.

Complete output field reference

Core processing fields

Field	Type	When present	Meaning
input	string	Always	Original submitted value.
success	boolean	Always	Whether note-detail extraction succeeded.
status	string	Always	Stable processing status; see Status values.
normalizedUrl	string	Success	Canonical explore URL without tracking/query parameters.
noteId	string	Success	24-character RedNote/Xiaohongshu note ID.
noteType	"video" | "image" | "unknown"	Success	Normalized note type.
scrapedAt	ISO 8601 string	Success	UTC time when the result was created.
duplicate	boolean	Duplicate only	true when this input resolves to an earlier canonical input in the same run.
duplicateOf	string	Duplicate only	Original input value of the first canonical record.
error	object	Failure	Safe machine-readable code and user-facing message.

Note content and timestamps

Field	Type	When present	Meaning
title	string	Success	Native note title. May be an empty string.
description	string	Success	Native note description/caption. May be empty.
createdAt	integer	When available	Source creation time as Unix milliseconds.
createdAtIso	ISO 8601 string	When createdAt is valid	UTC representation of createdAt.
updatedAt	integer	When available	Source update time as Unix milliseconds.
updatedAtIso	ISO 8601 string	When updatedAt is valid	UTC representation of updatedAt.
tags	object[]	Success	Note topics/tags. Timestamp-style moment markers are excluded.
tags[].id	string	When available	Source tag identifier.
tags[].name	string	For each tag	Tag name.

Author and engagement

Field	Type	When present	Meaning
author	object	Success	Public author fields included with the note.
author.userId	string	Success	Author user ID; may be empty when absent.
author.nickname	string	Success	Display name; may be empty.
author.avatarUrl	string	When available	Author avatar CDN URL.
author.profileUrl	string | null	Success	Locally generated public profile URL when userId exists; otherwise null.
author.redId	string	When available	Public Red ID included in the source.
author.verified	boolean	When available	Verification flag included in the source.
engagement	object	Success	Normalized engagement counters.
engagement.likes	integer	Success	Like count.
engagement.comments	integer	Success	Comment count.
engagement.collects	integer	Success	Collection/save count.
engagement.shares	integer	Success	Share count.

Images

Successful records always include the complete available image gallery.

Field	Type	When present	Meaning
images	object[]	Success	Ordered image gallery. May be empty.
images[].index	integer	For each image	Zero-based source order.
images[].url	string	For each image	Selected image URL.
images[].width / height	number	When available	Image dimensions in pixels.
images[].urlDefault	string	When available	Source default image URL.
images[].variants	object[]	When available	Alternate image representations.
images[].variants[].url	string	For each variant	Variant URL.
images[].variants[].width / height	number	When available	Variant dimensions in pixels.
images[].variants[].format	string	When available	Source format or image-scene label.

Video

Image notes return video: null. Video notes return complete available video metadata and streams.

Field	Type	When present	Meaning
video	object | null	Success	Video metadata for video notes; null for image notes.
video.durationSeconds	number	Video note	Duration in seconds; 0 when unavailable.
video.coverUrl	string	When available	Video cover image URL.
video.bestVideoUrl	string	Video URL available	Selected downloadable/playable video URL.
video.variants	object[]	Video note	Detected stream variants. May be empty.
video.variants[].codec	"h264" | "h265" | "av1" | "unknown"	For each variant	Video codec.
video.variants[].url	string	For each variant	Direct stream URL.
video.variants[].width / height	number	When available	Video dimensions in pixels.
video.variants[].duration	number	When available	Duration in seconds.
video.variants[].bitrate	number	When available	Source bitrate value.
video.variants[].sizeBytes	number	When available	Source-reported size in bytes.
video.variants[].qualityLabel	string	When available	Source quality label.

Status values

Only statuses reachable from the Note Detail processing path are listed here.

Status	Meaning	Output behavior	Charged?
success	A valid note was parsed and normalized.	Structured note result. Duplicate success records may add duplicate/duplicateOf.	One canonical note-detail-result.
invalid_input	Input was empty, malformed, or could not become a note identity.	success: false with error.	No
unsupported_url	Domain, protocol, or Xiaohongshu path is unsupported.	success: false with error.	No
note_not_found	The note was missing or no longer publicly accessible.	success: false with error.	No
access_denied	The public note request was denied.	success: false with error.	No
page_fetch_failed	Note retrieval failed after retries or returned an unusable response.	success: false with error.	No
parse_failed	A response was received but did not contain valid note data in a supported structure.	success: false with error.	No
internal_error	An unexpected processing error occurred.	success: false with a safe generic error.	No

Error codes

Error code	Status	Meaning
EMPTY_INPUT	invalid_input	Input was empty.
URL_NOT_FOUND	invalid_input	Input did not contain a supported URL.
XSEC_TOKEN_REQUIRED	invalid_input	The full note URL did not include the required token.
INVALID_URL	invalid_input	The extracted URL could not be parsed.
INPUT_REQUIRES_RESOLVABLE_URL	invalid_input	Input could not become a public note identity.
UNSUPPORTED_PROTOCOL	unsupported_url	URL protocol is unsupported.
UNSUPPORTED_DOMAIN	unsupported_url	URL is not on a supported RedNote/Xiaohongshu domain.
UNSUPPORTED_PATH	unsupported_url	Xiaohongshu URL is not a supported note path.
NOTE_NOT_FOUND	note_not_found	Note data was not found or is no longer publicly accessible.
ACCESS_DENIED	access_denied	Public note request was denied.
PAGE_FETCH_FAILED	page_fetch_failed	Public note page could not be fetched after retries.
INITIAL_STATE_NOT_FOUND	parse_failed	Expected public note data was absent from the page.
INITIAL_STATE_INVALID	parse_failed	Public page state was incomplete or invalid.
NOTE_DATA_INVALID	parse_failed	Note data had an unsupported structure.
INTERNAL_ERROR	internal_error	Unexpected error hidden behind a safe generic message.

Output examples

Image note

{
  "input": "https://www.xiaohongshu.com/explore/6a840ef900000000270231e6?xsec_token=...",
  "normalizedUrl": "https://www.xiaohongshu.com/explore/6a840ef900000000270231e6",
  "success": true,
  "status": "success",
  "noteId": "6a840ef900000000270231e6",
  "noteType": "image",
  "title": "",
  "description": "Example image-note description",
  "author": { "userId": "", "nickname": "Example author", "profileUrl": null },
  "engagement": { "likes": 0, "comments": 0, "collects": 0, "shares": 0 },
  "tags": [],
  "images": [
    { "index": 0, "url": "https://sns-webpic.example/image-1" },
    { "index": 1, "url": "https://sns-webpic.example/image-2" }
  ],
  "video": null,
  "scrapedAt": "2026-08-22T00:00:00.000Z"
}

Video note

{
  "input": "https://www.xiaohongshu.com/explore/6a87dbad0000000005030ca4?xsec_token=...",
  "normalizedUrl": "https://www.xiaohongshu.com/explore/6a87dbad0000000005030ca4",
  "success": true,
  "status": "success",
  "noteId": "6a87dbad0000000005030ca4",
  "noteType": "video",
  "title": "Example video note",
  "description": "Example description",
  "createdAt": 1766571252000,
  "createdAtIso": "2025-12-24T10:14:12.000Z",
  "updatedAt": 1766571253000,
  "updatedAtIso": "2025-12-24T10:14:13.000Z",
  "author": {
    "userId": "66ec990b000000001d031c8b",
    "nickname": "Example author",
    "profileUrl": "https://www.xiaohongshu.com/user/profile/66ec990b000000001d031c8b"
  },
  "engagement": { "likes": 1200, "comments": 20, "collects": 80, "shares": 10 },
  "tags": [{ "id": "topic-id", "name": "Example topic" }],
  "images": [{ "index": 0, "url": "https://sns-webpic.example/cover" }],
  "video": {
    "durationSeconds": 56,
    "coverUrl": "https://sns-webpic.example/cover",
    "bestVideoUrl": "https://sns-video.example/video.mp4",
    "variants": [
      {
        "codec": "h264",
        "url": "https://sns-video.example/video.mp4",
        "width": 1080,
        "height": 1920,
        "duration": 56
      }
    ]
  },
  "scrapedAt": "2026-08-22T00:00:00.000Z"
}

Duplicate input

{
  "input": "https://www.xiaohongshu.com/discovery/item/6a840ef900000000270231e6?xsec_token=...",
  "normalizedUrl": "https://www.xiaohongshu.com/explore/6a840ef900000000270231e6",
  "success": true,
  "status": "success",
  "noteId": "6a840ef900000000270231e6",
  "noteType": "image",
  "title": "Example note",
  "description": "Example description",
  "author": { "userId": "user-id", "nickname": "Example author", "profileUrl": "https://www.xiaohongshu.com/user/profile/user-id" },
  "engagement": { "likes": 10, "comments": 2, "collects": 3, "shares": 1 },
  "tags": [],
  "images": [],
  "video": null,
  "duplicate": true,
  "duplicateOf": "https://www.xiaohongshu.com/explore/6a840ef900000000270231e6?xsec_token=...",
  "scrapedAt": "2026-08-22T00:00:00.000Z"
}

Missing or inaccessible note

{
  "input": "https://www.xiaohongshu.com/explore/69f1df66000000003601fe34?xsec_token=...",
  "success": false,
  "status": "note_not_found",
  "error": {
    "code": "NOTE_NOT_FOUND",
    "message": "The RedNote note could not be found or is no longer publicly accessible."
  }
}

API usage

The Actor slug is lance_api/xiaohongshu-note-detail-scraper-api.

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lance_api/xiaohongshu-note-detail-scraper-api').call({
    urls: ['https://www.xiaohongshu.com/explore/6a673660000000002201bdf0?xsec_token=ABpmxG_iiqv6i0PvH66YtPs66TX1rjAfCHs8s4EGoqXdk=&xsec_source=pc_search&source=web_explore_feed'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(({ noteType, title, images, video, status }) => ({
    noteType, title, imageCount: images?.length, video, status,
})));

Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("lance_api/xiaohongshu-note-detail-scraper-api").call(run_input={
    "urls": ["https://www.xiaohongshu.com/explore/6a673660000000002201bdf0?xsec_token=ABpmxG_iiqv6i0PvH66YtPs66TX1rjAfCHs8s4EGoqXdk=&xsec_source=pc_search&source=web_explore_feed"],
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in items:
    print({
        "noteType": item.get("noteType"),
        "title": item.get("title"),
        "imageCount": len(item.get("images", [])),
        "video": item.get("video"),
        "status": item.get("status"),
    })

cURL

This synchronous endpoint runs the Actor and returns its default Dataset items:

curl -X POST \
  'https://api.apify.com/v2/acts/lance_api~xiaohongshu-note-detail-scraper-api/run-sync-get-dataset-items?format=json&clean=true' \
  -H "Authorization: Bearer ${APIFY_TOKEN}" \
  -H 'Content-Type: application/json' \
  -d '{
    "urls": ["https://www.xiaohongshu.com/explore/6a673660000000002201bdf0?xsec_token=ABpmxG_iiqv6i0PvH66YtPs66TX1rjAfCHs8s4EGoqXdk=&xsec_source=pc_search&source=web_explore_feed"]
  }'

💰 Simple, transparent pricing

Pricing is based on one successful canonical note result.

The standard price is $0.006 per successful note — $6 per 1,000. Eligible Apify plans can reduce this to $0.003 per note — $3 per 1,000. Check the Actor's Pricing tab for the current plan-specific rate.

Complete metadata, image galleries, covers, and available video URLs are included in the same result price.

Billing boundaries:

• A valid canonical note emits one note-detail-result.
• Invalid input, unsupported URLs, missing/invalid tokens, inaccessible or missing notes, fetch failures, parse failures, and internal failures emit no result event.
• Duplicate-only records do not add another charge; the canonical note is billed once.
• Image and video notes use the same successful-note event; returned media does not create another event.

Use cases

• Content research — Collect native titles, descriptions, tags, authors, timestamps, and engagement for qualitative or quantitative review.
• Creator and competitor monitoring — Feed public note records into dashboards and compare observable content and engagement over time.
• Media catalogs — Build structured indexes of image galleries, video covers, durations, and downloadable video URLs.
• Trend and product research — Use returned topics, captions, engagement, and media references as inputs to downstream analysis.
• Moderation and review workflows — Send one normalized record per submitted note into human-review queues while preserving failure status and source identity.
• Dataset enrichment — Add canonical RedNote note IDs, author profiles, engagement counters, and media metadata to existing datasets.
• AI and RAG context — Supply structured public-note data to downstream LLM, retrieval, summarization, or classification workflows.
• API automation — Run the Actor from Apify API, n8n, Make, Zapier, MCP clients, or scheduled data pipelines.

How it works

1. Validate each complete note URL and its required token.
2. Normalize supported URLs to a canonical note identity and URL.
3. Group equivalent inputs so the same note is resolved once per run.
4. Retrieve and normalize the public note detail.
5. Include complete available image and video details.
6. Save one ordered Dataset record for every submitted input, including duplicates and failures.

🤖 Use with AI agents

Use this Actor through the Apify MCP Server from ChatGPT, Claude, Cursor, Codex, or another MCP-compatible client. MCP runs use the same Actor input, output, and pricing as normal Apify runs.

Example prompt:

Use the Apify Actor lance_api/xiaohongshu-note-detail-scraper-api to retrieve structured details for these public RedNote/Xiaohongshu note URLs. Return the note type, native title, author, engagement, tags, images or video metadata, and processing status.

FAQ

Which RedNote/Xiaohongshu inputs are supported?

Use a complete /explore/, /discovery/item/, or /red_video/ URL containing its matching token.

Can I submit a note ID directly?

No. This lower-cost Actor requires the complete public note URL containing its matching token.

Can I process 1,000 notes at once?

Yes. urls accepts 1–1,000 items. Each submitted item receives one Dataset record.

Are duplicate notes charged twice?

No. Equivalent notes are resolved and billed once. Additional duplicate records contain duplicate: true and duplicateOf.

Are complete media details included automatically?

Yes. Successful records include the available image gallery and video metadata, including detected video URLs and variants, without another input switch or add-on event.

Are media URLs permanent?

No. They are RedNote/Xiaohongshu CDN URLs returned at scrape time, and some contain temporary signatures. Download or copy required media to your own authorized storage after retrieval.

Can this Actor process private notes?

No. It is designed for publicly accessible notes and does not automate login or bypass access controls.

What happens when a note is deleted or inaccessible?

The Actor returns a failure record such as note_not_found or access_denied. The failed input does not emit a note-detail result charge.

What does duplicateOf mean?

It contains the original input value of the first canonical record for the same note in the current run.

How am I charged?

A successful canonical note emits one result event. Complete available media is included. Failed and duplicate-only records are not charged.

Can AI agents use this Actor?

Yes. Use lance_api/xiaohongshu-note-detail-scraper-api through the Apify API or Apify MCP Server.

Limitations

• Public RedNote/Xiaohongshu notes only; private content and access-control bypass are not supported.
• Deleted, removed, unavailable, or permission-restricted notes can return failure records.
• Profile URLs, search URLs, and unsupported note paths are rejected.
• A missing, expired, invalid, or mismatched xsec_token can prevent the note from being resolved.
• CDN image, cover, avatar, and video URLs may expire and are not permanent storage links.
• Optional fields are omitted when they are absent or invalid in the source response.
• Engagement and other source values reflect what was available at scrape time.
• RedNote/Xiaohongshu response structures can change and temporarily affect extraction.
• The Actor returns media URLs; it does not permanently host media files.

Public data and responsible use

Use this Actor only for lawful processing of public data. Follow RedNote/Xiaohongshu terms, Apify terms, copyright rules, privacy obligations, and applicable law. Do not use it for harassment, spam, unlawful profiling, attempts to obtain non-public information, or attempts to bypass access controls. You are responsible for how you collect, store, share, and use the returned data and media URLs.

Support

For help, open an issue on the Actor page or email lanceapi2026@hotmail.com.

Include:

• Apify Run ID
• The affected public note URL
• Returned status and error.code
• Expected result versus actual result

When posting publicly on the Issues page, you may redact the xsec_token value from the example URL.

Do not send Apify tokens, cookies, session credentials, API keys, passwords, or other private credentials.