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:

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

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

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

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

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

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

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

Claude Desktop, Cursor, or VS Code

{
  "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 — 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.