# RedNote Note Detail API – Xiaohongshu Video & Images (`lance_api/xiaohongshu-note-detail-scraper-api`) Actor

Extract structured RedNote (Xiaohongshu/XHS) note details from video and image posts, including author data, engagement metrics, tags, image galleries, covers, and playable video stream URLs.

- **URL**: https://apify.com/lance\_api/xiaohongshu-note-detail-scraper-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** Social media, Developer tools, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 successful 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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 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:

```json
{
  "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:

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

Batch input:

```json
{
  "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

```json
{
  "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

```json
{
  "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

```json
{
  "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

```json
{
  "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

```json
{
  "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

```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

```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:

```bash
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.

# Actor input Schema

## `urls` (type: `array`):

Add 1–1000 full Xiaohongshu note URLs. Each URL must contain a valid xsec\_token query parameter. Open a public note from Xiaohongshu search, feed, or sharing, then copy the complete browser URL; xsec\_token appears after ? or & in that URL. A valid token makes direct note resolution more reliable. Note IDs and token-free URLs are not accepted by this Actor.

## Actor input object example

```json
{}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/xiaohongshu-note-detail-scraper-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lance_api/xiaohongshu-note-detail-scraper-api").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 '{}' |
apify call lance_api/xiaohongshu-note-detail-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/xiaohongshu-note-detail-scraper-api"
        }
    }
}

```

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/vlFPqvJ0ifN1jb7rm/builds/FcTC91aaedfzC26wO/openapi.json