RedNote (Xiaohongshu) Note Detail Scraper API – No xsec_token Required

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

No xsec_token is required for normal use. If you already have a valid token in the URL or provide one separately, the Actor can use it when resolving that public note.

Submit a 24-character note ID, a supported Xiaohongshu URL, an xhslink.com or xhslink.cn short link, or complete app share text. Process 1–1,000 inputs 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. Keep the downloadable-video option off when metadata and media details are enough, and pay for the video URL add-on only when a URL is requested and successfully returned.

Note details cost $20 per 1,000 successful notes at the standard rate, or as little as $17 per 1,000 with the lowest eligible Store rate. The optional downloadable video URL follows the same per-result pricing.

✨ 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.
• Flexible RedNote inputs — Submit note IDs, supported full URLs, short links, or app share text without building separate parsers.
• 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.
• Optional downloadable video URL add-on — Request a playable video URL only when needed, keeping metadata-only runs lighter and avoiding unnecessary add-on charges.

🚀 Quick start

In Apify Console:

1. Add one or more note IDs, URLs, short links, or supported share texts to urls.
2. Keep the default options for normal note-detail extraction.
3. Click Start.
4. Open the run's Dataset.
5. Read one structured result record for each submitted input.

Minimal input:

{
  "urls": ["6428b7be000000001300d335"]
}

Supported RedNote / Xiaohongshu inputs

The Actor accepts:

• A 24-character hexadecimal note ID, such as 6428b7be000000001300d335
• https://www.xiaohongshu.com/explore/{noteId}
• https://www.xiaohongshu.com/discovery/item/{noteId}
• https://www.xiaohongshu.com/red_video/{noteId}
• HTTP or HTTPS xhslink.com short links
• HTTP or HTTPS xhslink.cn short links
• Complete app share text containing one supported URL
• Markdown-wrapped supported links

The Actor follows supported short-link redirects, extracts the note ID, and returns a canonical normalizedUrl in the form https://www.xiaohongshu.com/explore/{noteId}. Tracking and query parameters are not included in normalizedUrl.

Profile pages, search pages, unrelated domains, unsupported Xiaohongshu paths, and text without a supported URL or note ID are rejected with a structured failure result.

Note IDs and xsec_token

A note ID is the preferred input. Find it in a supported note URL after /explore/, /discovery/item/, or /red_video/, or in the noteId/id field returned by a search or user-notes workflow.

A valid xsec_token can improve resolution reliability for public notes that require it, but it is not required for normal use. Submit a note ID or URL without a token, use a URL that already contains xsec_token, or provide it through the separate xsecToken input.

If both are present, the separate xsecToken input takes precedence over the token in the URL. The separate field applies to the run, so keep different note-specific tokens in their matching URLs when processing a batch. A missing token is allowed. An expired or invalid token can cause resolution to fail. Tokens and other query parameters are not included in normalizedUrl.

Input

Field	Type	Required	Default	Limits	Description
urls	string[]	Yes	None	1–1,000 items	Note IDs, supported full URLs, short links, Markdown links, or app share text. Values are trimmed, normalized, and deduplicated by canonical note identity.
xsecToken	string	No	Empty	One run-level value	Optional token for a public note. It overrides a token found in the URL and is best suited to a single-note run. For note-specific batch tokens, keep each token in its corresponding URL.
includeMedia	boolean	No	true	—	When true, include images and the video object. When false, omit both and return a smaller metadata-only record.
includeVideoUrl	boolean	No	false	—	Paid add-on for video notes. When enabled together with includeMedia, return video.bestVideoUrl if available and emit one video-url-result unit.
includeAllVideoQualities	boolean	No	true	—	When the video URL add-on is enabled, include all detected video variants. Set to false to keep only bestVideoUrl.

includeVideoUrl is effective only when includeMedia is also enabled. Setting includeMedia: false omits media output and disables the video URL add-on for that run.

Input examples

Metadata-only analysis:

{
  "urls": ["6428b7be000000001300d335"],
  "includeMedia": false
}

Image galleries and video metadata, without a downloadable video URL:

{
  "urls": [
    "https://www.xiaohongshu.com/explore/6428b7be000000001300d335",
    "https://xhslink.com/example"
  ],
  "includeMedia": true,
  "includeVideoUrl": false
}

Video note with downloadable URL and all detected qualities:

{
  "urls": ["6a87dbad0000000005030ca4"],
  "includeMedia": true,
  "includeVideoUrl": true,
  "includeAllVideoQualities": true
}

Short output example

{
  "input": "6428b7be000000001300d335",
  "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

The entire images field is omitted when includeMedia is false.

Field	Type	When present	Meaning
images	object[]	includeMedia: true	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

The entire video field is omitted when includeMedia is false. With media enabled, image notes return video: null.

Field	Type	When present	Meaning
video	object | null	includeMedia: true	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	Add-on enabled and URL found	Selected downloadable/playable video URL.
video.variants	object[]	Add-on and all qualities enabled	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; optional video URL unit when returned.
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
short_link_resolution_failed	A supported short link could not resolve to a valid destination.	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	Text did not contain a supported URL or note ID.
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.
SHORT_LINK_RESOLUTION_FAILED	short_link_resolution_failed	Short-link redirect failed or returned an invalid destination.
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": "6a840ef900000000270231e6",
  "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 with the optional downloadable URL

{
  "input": "6a87dbad0000000005030ca4",
  "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",
  "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": "6a840ef900000000270231e6",
  "scrapedAt": "2026-08-22T00:00:00.000Z"
}

Missing or inaccessible note

{
  "input": "https://www.xiaohongshu.com/explore/69f1df66000000003601fe34",
  "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 real Actor slug is lance_api/rednote-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/rednote-note-detail-scraper-api').call({
    urls: ['6428b7be000000001300d335'],
    includeMedia: true,
    includeVideoUrl: false,
});

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/rednote-note-detail-scraper-api").call(run_input={
    "urls": ["6428b7be000000001300d335"],
    "includeMedia": True,
    "includeVideoUrl": False,
})

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~rednote-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": ["6428b7be000000001300d335"],
    "includeMedia": true,
    "includeVideoUrl": false
  }'

💰 Simple, transparent pricing

Pricing uses a base result plus an optional video URL add-on:

Billable result	Event	Standard price	Per 1,000	Lowest eligible price	Lowest per 1,000
Successfully parsed note	note-detail-result	$0.020	$20	$0.017	$17
Successfully returned downloadable video URL	video-url-result	$0.020	$20	$0.017	$17

Note detail extraction starts from $17 per 1,000 successful notes with the lowest eligible Apify Store rate. Downloadable video URL lookup also starts from $17 per 1,000 successful URLs. The standard rate is $20 per 1,000 for each result type. Check the Actor's Pricing tab for the current plan-specific rate.

Keep includeVideoUrl off when note metadata, image galleries, cover, and duration are enough. Enable it only when you need a downloadable video URL, so you avoid unnecessary video URL charges.

Billing boundaries:

• A valid canonical note emits one note-detail-result, whether includeMedia is on or off.
• Invalid input, unsupported URLs, failed short links, 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.
• includeVideoUrl: false emits no video-url-result.
• includeMedia: false disables the video URL add-on and emits no video-url-result.
• If includeVideoUrl: true but no downloadable URL is returned, no video-url-result is emitted. If the optional lookup causes the whole note resolution to fail, neither result event is emitted.
• Enabling the option for an image note emits only the base note event.
• One video note emits at most one video-url-result, even when multiple variants are returned.
• There is no Actor-specific start event in the current billing code.

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 optional 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. Parse each submitted note ID, full URL, short link, Markdown link, or share text.
2. Normalize supported inputs 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 or omit image/video metadata according to includeMedia.
6. Optionally resolve and return a downloadable video URL when requested.
7. 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/rednote-note-detail-scraper-api to retrieve structured details for these public RedNote/Xiaohongshu notes. Return the note type, native title, author, engagement, tags, images or video metadata, and processing status. Request downloadable video URLs only for video notes when needed.

FAQ

Which RedNote/Xiaohongshu inputs are supported?

Use a 24-character note ID, a supported /explore/, /discovery/item/, or /red_video/ URL, an xhslink.com/xhslink.cn short link, a Markdown-wrapped supported URL, or app share text containing one supported URL.

Can I submit a note ID directly?

Yes. A 24-character hexadecimal note ID is the preferred input and is converted to a canonical explore URL.

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.

What is the difference between includeMedia and includeVideoUrl?

includeMedia controls whether images and the video metadata object are returned. includeVideoUrl is a paid add-on inside that media output and controls video.bestVideoUrl; it does not replace includeMedia.

Does enabling includeVideoUrl always return a video URL?

No. It is meaningful only for video notes and depends on a downloadable stream being available. No video URL event is charged when a URL is not returned.

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 base result event. A requested and successfully returned downloadable video URL emits one additional event. Failed and duplicate-only records are not charged.

Can AI agents use this Actor?

Yes. Use the real slug lance_api/rednote-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.
• Short links depend on a successful redirect and can expire or stop resolving.
• xsec_token values are short-lived and can expire or become invalid.
• 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:

• Run ID
• A non-sensitive note ID or public URL
• Returned status and error.code
• Expected result versus actual result

Do not send Apify tokens, cookies, session credentials, sensitive xsec_token values, API keys, passwords, or other secrets.