# RedNote Note Detail Scraper (`automation-lab/rednote-note-detail-scraper`) Actor

📝 Extract complete public RedNote/Xiaohongshu note records from signed note or share URLs: content, authors, topics, engagement, images, and video metadata.

- **URL**: https://apify.com/automation-lab/rednote-note-detail-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.32 / 1,000 note detail extracteds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Note Detail Scraper

Extract complete public **RedNote (Xiaohongshu / 小红书) note details** from signed note links or public share links.
Get structured text, author data, topics, engagement counts, images, and video metadata without copying fields by hand.

- 📝 Turn a public note URL into one clean dataset row
- 👤 Capture author ID, name, and avatar
- 📊 Track likes, comments, collections, and shares
- 🖼️ Export image CDN URLs, file IDs, widths, and heights
- 🎬 Collect public video stream metadata when the note is a video
- 🔁 Re-run campaign links to monitor engagement over time

The Actor uses an HTTP-first route and reads the public server-rendered note state.
It does not require a RedNote account or user cookies for supported signed public URLs.

### What does RedNote Note Detail Scraper do?

RedNote Note Detail Scraper accepts complete public note URLs and returns normalized records ready for JSON, CSV, Excel, API, or automation workflows.

A supported run can extract:

- note ID and note type
- title and full description text
- publish and update timestamps
- author ID, nickname, and avatar URL
- topic names and topic IDs
- like, comment, collection, and share counts
- image URLs, image file IDs, and dimensions
- video stream URLs, cover, duration, and dimensions when available
- public source and resolved URLs
- scrape timestamp for historical comparisons

One note becomes one dataset item.
Duplicate links resolving to the same note are saved only once.

### Who is this Xiaohongshu note scraper for?

#### Social-listening teams

Collect a stable snapshot of campaign posts and compare engagement across scheduled runs.
Feed the results into dashboards, alerts, or sentiment-analysis systems.

#### China-market researchers

Build a structured corpus of public RedNote content for topic, creator, and visual-content analysis.
Preserve source URLs and timestamps for traceability.

#### Brands and agencies

Monitor sponsored posts, creator collaborations, product mentions, and campaign performance.
Export note-level metrics without manual spreadsheets.

#### Creator analysts

Compare public content formats, topic usage, and engagement signals across a curated set of notes.
Use the separate profile actor when profile-level statistics are the primary goal.

#### Data and AI teams

Send normalized note text and metadata to a warehouse, vector database, classifier, or LLM pipeline.

### Why use this RedNote data extractor?

- ⚡ **HTTP-first:** avoids browser startup for the proven public SSR route.
- 🎯 **Narrow contract:** signed note details only, without unreliable bare-ID promises.
- 🧱 **Structured output:** numbers are numbers and timestamps use ISO 8601.
- 🔍 **Traceable:** source and final resolved URLs stay in each row.
- 🔁 **Repeatable:** use Tasks or schedules for campaign monitoring.
- 🛡️ **Fail-closed validation:** unsupported hosts and unsigned full URLs are rejected.
- 🌐 **Optional proxy fallback:** direct access is attempted first; a configured proxy is used only after retries.

### What RedNote data can I extract?

| Field group | Example fields | Use |
|---|---|---|
| Identity | `noteId`, `noteType` | Join and deduplicate records |
| Content | `title`, `text` | Search, NLP, and content analysis |
| Time | `publishedAt`, `updatedAt`, `scrapedAt` | Freshness and history tracking |
| Author | `authorId`, `authorName`, `authorAvatarUrl` | Creator attribution |
| Topics | `topicIds`, `topicNames` | Trend and campaign grouping |
| Engagement | `likeCount`, `commentCount`, `collectCount`, `shareCount` | Performance analysis |
| Images | `imageUrls`, `imageFileIds`, `imageWidths`, `imageHeights` | Media archives and visual analysis |
| Video | `videoUrls`, `videoCoverUrl`, `videoDurationSeconds` | Video processing workflows |
| Source | `sourceUrl`, `resolvedUrl`, `xsecToken` | Auditing and repeat runs |

Fields absent from the public note are omitted or returned as empty arrays/strings where the schema requires a stable shape.

### Supported RedNote and Xiaohongshu URLs

Use either:

1. A complete public `xiaohongshu.com/explore/<note-id>` URL containing `xsec_token`.
2. A complete public `xiaohongshu.com/discovery/item/<note-id>` URL containing `xsec_token`.
3. A public `xhslink.com` share URL that redirects to one of those signed note pages.

Example:

```text
https://www.xiaohongshu.com/explore/6424f3dd000000001300461c?xsec_token=PUBLIC_TOKEN&xsec_source=
````

Bare note IDs and unsigned full URLs are intentionally outside v1.
They commonly lead to verification or unavailable pages and would create misleading success claims.

### How to scrape a RedNote note in 4 steps

1. Open a public RedNote note or share link in your browser.
2. Copy the complete URL, including its `xsec_token` when using a Xiaohongshu URL.
3. Paste one or more links into **Note or share URLs**.
4. Click **Start** and export the resulting dataset.

For a first run, keep **Maximum notes** at `1`.
This exercises the full product contract quickly and cheaply.

### Input parameters

#### Note or share URLs

`startUrls` is required.
It accepts request-list entries from the Apify Console or API.
Each entry must point to the public RedNote/Xiaohongshu note scope described above.

#### Maximum notes

`maxItems` limits unique saved note records.
The allowed range is 1 to 100 and the default is 10.

#### Retries per note

`maxRetries` controls bounded retries for temporary network or source failures.
The default is 2 and the maximum is 4.

#### Request timeout

`requestTimeoutSecs` limits each page request to 10-90 seconds.
The default is 30 seconds.

#### Proxy configuration

`proxyConfiguration` is optional.
Direct HTTP runs first because it is cheaper and works for the verified public route.
If configured, Apify Proxy is used only as the final fallback.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://www.xiaohongshu.com/explore/6424f3dd000000001300461c?xsec_token=ABqxb5IJpswB7KdeVe7e-nExCzBN2dcUTrDVtd-IqM3QI=&xsec_source="
    }
  ],
  "maxItems": 1,
  "maxRetries": 2,
  "requestTimeoutSecs": 30
}
```

The prefilled sample is deliberately small so the first run finishes quickly.
Replace it with your own current public note links for production work.

### Example output

```json
{
  "noteId": "6424f3dd000000001300461c",
  "noteType": "normal",
  "title": "其中有个两个娃的妈",
  "text": "Chuu家的衣服就是粉粉嫩嫩...",
  "publishedAt": "2023-03-30T02:28:45.000Z",
  "updatedAt": "2023-03-30T02:28:46.000Z",
  "authorId": "567f517e82ec39377fd79fe0",
  "authorName": "嘉嘉&毛毛",
  "topicNames": ["穿搭", "chuu", "春天", "粉粉嫩嫩", "OotD"],
  "likeCount": 1113,
  "commentCount": 468,
  "collectCount": 77,
  "shareCount": 22,
  "mediaType": "image",
  "imageCount": 1,
  "imageWidths": [1276],
  "imageHeights": [1702],
  "scrapedAt": "2026-07-19T00:00:00.000Z"
}
```

The live output also includes full source, author-avatar, image-CDN, and public token fields.
Video notes include video fields when those values are present in the page state.

### How much does it cost to scrape RedNote note details?

This Actor uses pay-per-event pricing:

- a small one-time Actor start event
- one `result` event for each complete note record saved

| Event | Free | Starter / Bronze | Scale / Silver | Business / Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Note detail | $0.0006064 | $0.0005273 | $0.0004113 | $0.00031638 | $0.00021092 | $0.00014765 |

Higher subscription tiers receive volume discounts.
The exact current prices shown in Apify Console are authoritative.
You are not charged a result event for an input that fails extraction or for a duplicate note.

Use `maxItems: 1` for a low-cost trial.
Before starting a larger run, use Apify's maximum total charge setting if you need a strict spending ceiling.

### Tips for reliable note extraction

- ✅ Copy the complete URL instead of only the 24-character note ID.
- ✅ Keep the `xsec_token` query parameter intact.
- ✅ Prefer current share links from a publicly accessible post.
- ✅ Use small batches when testing a new source list.
- ✅ Re-run the same URL list on a schedule to compare engagement snapshots.
- ✅ Configure a proxy only when direct requests show region- or IP-specific blocking.
- ❌ Do not submit profile, search, comments, or feed URLs to this note-detail Actor.
- ❌ Do not assume an old public token remains valid forever.

### Integrations and automation workflows

#### Google Sheets campaign tracker

Schedule the Actor daily, connect the dataset through Make or Zapier, and append engagement counts to a sheet keyed by `noteId`.

#### Data warehouse ingestion

Pull dataset rows through the Apify API and upsert them into BigQuery, Snowflake, PostgreSQL, or another warehouse.
Use `noteId` as the stable entity key and `scrapedAt` as the snapshot time.

#### Slack or email alerts

Compare the latest counts with a previous run and alert when comments, shares, or collections cross campaign thresholds.

#### LLM content analysis

Send `title`, `text`, `topicNames`, and engagement fields to a classifier or LLM for themes, brand-safety labels, summaries, or campaign coding.

#### Media archive

Use `imageUrls` and `videoUrls` as source references for an authorized downstream archival workflow.
Respect source rights and retention rules.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rednote-note-detail-scraper').call({
  startUrls: [{
    url: 'https://www.xiaohongshu.com/explore/NOTE_ID?xsec_token=PUBLIC_TOKEN'
  }],
  maxItems: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Keep the token in an environment variable rather than source control.

### Use the Actor with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/rednote-note-detail-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.xiaohongshu.com/explore/NOTE_ID?xsec_token=PUBLIC_TOKEN'
    }],
    'maxItems': 1,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use the Actor with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~rednote-note-detail-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{
      "url": "https://www.xiaohongshu.com/explore/NOTE_ID?xsec_token=PUBLIC_TOKEN"
    }],
    "maxItems": 1
  }'
```

Read the run's `defaultDatasetId`, then fetch its items from the dataset API.

### Use RedNote Note Detail Scraper with MCP

Apify MCP lets Claude Code, Claude Desktop, Cursor, and VS Code run this Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/rednote-note-detail-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/rednote-note-detail-scraper"
    }
  }
}
```

Example prompts:

- “Extract this signed RedNote note and summarize its topics and engagement.”
- “Run these campaign note URLs and rank them by collection count.”
- “Get the image dimensions and CDN links from this Xiaohongshu note.”

### Data quality and normalization

Engagement values are converted to non-negative numbers, including abbreviated values when the source uses thousand or ten-thousand units.
Timestamps are normalized to ISO 8601 UTC strings.
HTTP media links are upgraded to HTTPS in output.
Arrays preserve source order where useful.

The Actor reads public server-rendered state rather than estimating values from visible labels.
However, RedNote can change its page structure, omit fields, or vary fields by note type.
Inspect your first output before building a downstream contract around optional fields.

### Error handling

Each note has bounded retries.
A failed URL is logged and skipped when another URL succeeds.
If every input fails, the run ends with a non-zero status instead of returning a misleading empty success.

Duplicate URLs or different share URLs resolving to the same `noteId` produce one billed dataset result.
Invalid domains, unsupported paths, and unsigned Xiaohongshu full URLs fail closed during validation.

### Limitations

- Only complete public note and share URLs are supported in v1.
- Bare note IDs are not resolved.
- Private, deleted, login-only, age-restricted, or geographically unavailable notes cannot be guaranteed.
- A public signed token may expire or stop resolving.
- Comments and reply threads are not extracted by this Actor.
- Profile histories, search results, and feed discovery are separate workflows.
- Video metadata depends on what the public initial state exposes for that note.
- Source layout or anti-bot changes can temporarily affect extraction.

### Is it legal to scrape RedNote?

This Actor extracts publicly accessible page data supplied by the user.
Public availability does not remove all legal or contractual obligations.

You are responsible for:

- following applicable laws and platform terms
- respecting copyright, privacy, and database rights
- avoiding collection of sensitive personal data without a lawful basis
- using reasonable request volumes
- honoring deletion, retention, and data-subject requirements
- ensuring your media usage is authorized

This documentation is not legal advice.
If your use case involves personal profiling, regulated decisions, or commercial reuse of media, obtain appropriate legal guidance.

### Troubleshooting

#### Why does my URL say it is missing `xsec_token`?

You supplied a full Xiaohongshu note URL without its public signature.
Copy the complete current link from the public note or use its public `xhslink.com` share URL.
Do not submit only the note ID.

#### Why did the run extract no notes?

Open the source link in a logged-out browser.
The note may be deleted, private, expired, restricted, or returning a verification page.
Check the run log for the final HTTP or parsing error.
Try a fresh public share link before enabling a proxy.

#### Why is a media field empty?

Image and video note shapes differ.
The Actor only returns media fields exposed in the note's public server state.
An image note normally has no video stream fields.

#### Why was a duplicate link skipped?

Multiple share URLs can resolve to the same note ID.
The Actor deduplicates by `noteId` so the dataset and PPE charge reflect unique note records.

### FAQ

#### Does the Actor need RedNote cookies or login credentials?

No for supported signed public note URLs.
The verified route works anonymously and the input schema does not request account credentials.

#### Can it scrape many notes?

Yes, up to 100 unique notes per run.
Start small and use conservative scheduling because the product performs one public note-page request per input.

#### Can it extract comments?

No.
This Actor returns note-level comment counts, not comment bodies or reply threads.
Choose a dedicated comments workflow when you need conversations.

#### Can it discover notes by keyword?

No.
The v1 contract starts from public note/share URLs.
Discovery, search, and creator-profile collection are different products with different reliability requirements.

#### Can I export CSV or Excel?

Yes.
Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, and other supported formats.

#### Is `xsecToken` secret?

It is copied from the public signed source link/page state used for the run.
Treat source URLs according to your own security and retention policies.

### Related RedNote scrapers

- [RedNote Creator Profile Scraper](https://apify.com/automation-lab/rednote-creator-profile-scraper) — use when creator profile data is the primary entity.

This Actor intentionally stays focused on note-detail extraction.
A narrow product makes validation, output schemas, billing, and downstream automation easier to understand.

### Support

If a valid current public signed note fails, share the run URL through the Apify Console issue form.
Include whether the URL works in a logged-out browser and whether you configured a proxy.
Do not paste private account credentials or unrelated personal data into support messages.

# Actor input Schema

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

Complete public Xiaohongshu/RedNote note URLs. Bare note IDs and unsigned note URLs are intentionally rejected.

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

Maximum number of unique note records to save.

## `maxRetries` (type: `integer`):

Retry temporary page or network failures before skipping a note.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each RedNote page request.

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

Optionally use Apify Proxy as a fallback for region- or IP-specific blocking.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.xiaohongshu.com/explore/6424f3dd000000001300461c?xsec_token=ABqxb5IJpswB7KdeVe7e-nExCzBN2dcUTrDVtd-IqM3QI=&xsec_source="
    }
  ],
  "maxItems": 1,
  "maxRetries": 2,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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/6424f3dd000000001300461c?xsec_token=ABqxb5IJpswB7KdeVe7e-nExCzBN2dcUTrDVtd-IqM3QI=&xsec_source="
        }
    ],
    "maxItems": 1,
    "maxRetries": 2,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rednote-note-detail-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/6424f3dd000000001300461c?xsec_token=ABqxb5IJpswB7KdeVe7e-nExCzBN2dcUTrDVtd-IqM3QI=&xsec_source=" }],
    "maxItems": 1,
    "maxRetries": 2,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rednote-note-detail-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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/6424f3dd000000001300461c?xsec_token=ABqxb5IJpswB7KdeVe7e-nExCzBN2dcUTrDVtd-IqM3QI=&xsec_source="
    }
  ],
  "maxItems": 1,
  "maxRetries": 2,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/rednote-note-detail-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/rednote-note-detail-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote Note Detail Scraper",
        "description": "📝 Extract complete public RedNote/Xiaohongshu note records from signed note or share URLs: content, authors, topics, engagement, images, and video metadata.",
        "version": "0.1",
        "x-build-id": "NqOfgtyY5rvEWqvsm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rednote-note-detail-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rednote-note-detail-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~rednote-note-detail-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rednote-note-detail-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~rednote-note-detail-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rednote-note-detail-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Note or share URLs",
                        "type": "array",
                        "description": "Complete public Xiaohongshu/RedNote note URLs. Bare note IDs and unsigned note URLs are intentionally rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum notes",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of unique note records to save.",
                        "default": 10
                    },
                    "maxRetries": {
                        "title": "Retries per note",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Retry temporary page or network failures before skipping a note.",
                        "default": 2
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Maximum time to wait for each RedNote page request.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optionally use Apify Proxy as a fallback for region- or IP-specific blocking."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```