# RedNote / Xiaohongshu Video Transcript Scraper (`hgservices/xiaohongshu-transcript-scraper`) Actor

Scrape auto-generated video transcripts from RedNote (Xiaohongshu, 小红书, Little Red Book): Chinese ASR captions, English machine translations, timestamped segments, plain text, and SRT files. No login required.

- **URL**: https://apify.com/hgservices/xiaohongshu-transcript-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 saved transcripts

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does the RedNote / Xiaohongshu Video Transcript Scraper do?

**RedNote / Xiaohongshu Video Transcript Scraper** extracts **video transcripts and captions** from [RedNote](https://www.xiaohongshu.com) — the international name of **Xiaohongshu (小红书, Little Red Book)**, China's largest lifestyle and shopping platform. Paste a video link and get the **full spoken content of the video**: the original **Chinese auto-generated captions** plus RedNote's **machine translations** (including English), as **timestamped segments**, **plain text**, and optional **SRT subtitle files**. One video per run — for more videos, run the Actor again for each.

The Actor works **without a RedNote account, without login, and without cookies**. Every transcript also comes with note metadata: title, description, author, publish date, video duration, and engagement stats (likes, collects, comments, shares).

Run it on the [Apify platform](https://apify.com) and you get **API access, scheduling, webhooks, proxy rotation, monitoring**, and dataset exports to **JSON, CSV, Excel, or HTML** with every run.

### Why use the RedNote transcript scraper?

- **Transcribe RedNote videos at scale** — one video per run; chain runs through the API or scheduling to process any volume.
- **Content repurposing** — turn spoken video content into blog posts, subtitles, or searchable archives.
- **Sentiment & voice-of-customer analysis** — feed authentic consumer speech from Xiaohongshu into NLP or LLM pipelines, in Chinese or in English.
- **Market research** — analyze what creators say about products, brands, and trends.
- **Accessibility** — get captions for any speech-heavy video, in SRT or JSON form.
- **No account needed** — public videos only, zero risk to your RedNote account.

### How to use the RedNote transcript scraper in Apify Console

1. Open a video in the RedNote (Xiaohongshu) **app** and tap **Share → Copy link**. You get a short link like `http://xhslink.com/...` that never expires. Pasting the **whole share message** (title, link, emojis) also works — the Actor extracts the link automatically.
2. Go to the Actor's page in [Apify Console](https://console.apify.com) and open the **Input** tab.
3. Paste your link into **Video link**. To transcribe several videos, start one run per video.
4. Optional: adjust the settings described in the Input section below.
5. Click **Start** and wait for the run to finish.
6. Preview or download the transcripts from the **Output** tab — as JSON, CSV, Excel, or HTML. Enable **Save raw SRT files** to also get downloadable `.srt` subtitle files.

#### Supported link types

| Link type | Example | Where the user gets it |
|---|---|---|
| **App share short link** (recommended — never expires) | `http://xhslink.com/aB3xYz9` | RedNote app → open the video → **Share → Copy link** |
| **Whole share message** (link extracted automatically) | `23 失业两年 靠男朋友养 2.0 https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=AB…=&xsec_source=home_feed 来小红书发现美好生活 😂` | RedNote app → **Share → Copy text**, then paste everything |
| **Browser note URL with token** (token expires in hours/days) | `https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=ABzp0Ud9Y6R-rXTfwiOnqYt-pJwnM7iRRn6gF91oGkXjM=&xsec_source=home_feed` | Desktop browser → open the video on [xiaohongshu.com](https://www.xiaohongshu.com) → copy the **full** address bar, including `?xsec_token=...` |

Not supported:

- **Bare note IDs** (for example `6a8732a2000000001700bf41`) — RedNote serves no note data for them without a token.
- **Note URLs without `xsec_token`** — usually rejected; share the video from the app instead.

### Input

Configure the Actor in the **Input** tab:

| Field | Type | Default | Description |
|---|---|---|---|
| **Video link** | string | — (required) | One RedNote (Xiaohongshu) share link or note URL (see the table above). One video per run — for more videos, run the Actor again for each. |
| **Include timestamped segments** | boolean | `true` | Keep per-line caption segments with start/end timecodes |
| **Include plain text transcript** | boolean | `true` | Keep the whole transcript as one text block |
| **Save raw SRT files** | boolean | `false` | Store each fetched track as an `.srt` file in the run's key-value store |

### Output

Each input link produces **one dataset row per caption track**. A video with an original Chinese track and an English machine translation gives two rows. The note fields (title, author, stats) repeat on every row, so the output stays flat and opens cleanly in CSV or Excel.

```json
{
  "noteId": "6a83d8900000000008012d64",
  "url": "https://www.xiaohongshu.com/explore/6a83d8900000000008012d64?xsec_token=...&xsec_source=home_feed",
  "title": "以为很贵......结果一箱才9.9r而已",
  "authorName": "手作月饼铺子",
  "language": "zh-CN",
  "track": "source",
  "isMachineTranslation": false,
  "segmentCount": 18,
  "text": "大家好 今天给大家开箱\n...",
  "segments": [
    { "startMs": 480, "endMs": 2412, "start": "00:00:00,480", "end": "00:00:02,412", "text": "大家好 今天给大家开箱" }
  ],
  "srtUrl": "https://sns-subtitle-s10.xhscdn.com/subtitle/....srt",
  "videoDuration": "0:37",
  "videoDurationMs": 37000,
  "likes": 1303,
  "collects": 527,
  "comments": 168,
  "shares": 85,
  "postedAt": "2026-08-15T09:19:12+00:00",
  "description": "开箱视频...",
  "authorId": "6a43a15a000000000e03d001",
  "availableSubtitleLanguages": ["en-US", "source", "zh-CN"],
  "status": "OK",
  "scrapedAt": "2026-09-16T10:00:00+00:00"
}
```

A note with no transcript (an image post, a video without captions, or a failed fetch) still produces one row. Its `language`, `track`, and `text` fields are empty, and `status` gives the reason.

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Possible `status` values:

| Status | Meaning |
|---|---|
| `OK` | Transcript scraped |
| `NOT_A_VIDEO` | The note is an image post — no transcript can exist |
| `NO_SUBTITLES` | Video has no auto-captions (typically music-only clips) |
| `LANGUAGE_NOT_AVAILABLE` | None of the requested languages exist on this video; see `availableSubtitleLanguages` |
| `SUBTITLE_FETCH_FAILED` | Note loaded but no subtitle file could be downloaded; see the `error` field |
| `ERROR` | Link could not be scraped (see the `error` field) |

### Data table

Main fields of every dataset row:

| Field | Description |
|---|---|
| `noteId` | RedNote note ID (24 hex chars) |
| `url` | The URL you supplied |
| `title` | Note title |
| `authorName`, `authorId` | Author nickname and user ID |
| `language` | Language of this row's transcript |
| `track` | Track key — `source` is the original auto-caption track |
| `isMachineTranslation` | `true` when the row is a machine translation |
| `segmentCount` | Number of timestamped segments in this row |
| `text` | Full plain-text transcript, one segment per line |
| `segments[]` | Timestamped segments: `startMs`, `endMs`, `start`, `end`, `text` |
| `srtUrl` | URL of the source `.srt` subtitle file (link expires) |
| `videoDuration`, `videoDurationMs` | Video length, human-readable and in milliseconds |
| `likes`, `collects`, `comments`, `shares` | Engagement counts |
| `postedAt` | Publish time (ISO 8601, UTC) |
| `description` | Note text body |
| `availableSubtitleLanguages` | All caption tracks RedNote generated for the video |
| `status`, `error`, `scrapedAt` | Run diagnostics |

### How to use the RedNote transcript scraper via API

The Actor exposes the standard Apify Actor API. You can run it, wait, and receive the transcripts in a single request:

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~xiaohongshu-transcript-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "startUrl": "http://xhslink.com/aB3xYz9"
      }'
```

**Input:** JSON with the same fields as the Input tab. `startUrl` is a single string — a share link, a whole share message, or a fresh tokened note URL (see *Supported link types* above). To transcribe more videos, start one run per video.

**Output:** an array with one object per caption track. Each object carries a `status` field:

- `OK` — the row holds a transcript (segments + plain text).
- `ERROR` — the link could not be scraped; the `error` string tells you whether the share-link token expired ("paste a fresh share link") or the proxy was blocked.
- `NOT_A_VIDEO`, `NO_SUBTITLES`, `LANGUAGE_NOT_AVAILABLE`, `SUBTITLE_FETCH_FAILED` — the note loaded but no transcript exists for it; see the status table above.

**Important:** the run itself finishes with status `SUCCEEDED` even when individual notes fail. Always branch on the per-item `status`, never on the run status.

Async usage (start now, poll later) and webhooks work through the standard [Apify Actor API endpoints](https://docs.apify.com/api/v2#/reference/actors/run-collection).

### Use the RedNote scraper with AI tools

You can plug this Actor into Claude, Claude Code, Cursor, and other MCP-compatible AI tools through the hosted [Apify MCP server](https://apify.com/docs/mcp). The Actor becomes a tool the AI can call whenever it needs a RedNote or Xiaohongshu transcript.

#### Claude Code

```bash
claude mcp add --transport http apify-rednote "https://mcp.apify.com/mcp?actors=hgservices~xiaohongshu-transcript-scraper"
```

Then just ask:

> Get the transcript of this RedNote video `http://xhslink.com/aB3xYz9` and summarize it in English.

Claude runs the Actor, reads the transcript rows, and answers with the content.

#### Claude Desktop and other MCP clients

Add the server to your MCP client configuration:

```json
{
  "mcpServers": {
    "apify-rednote": {
      "url": "https://mcp.apify.com/mcp?actors=hgservices~xiaohongshu-transcript-scraper"
    }
  }
}
```

#### Custom agents and function calling

For your own LLM agents, the one-request API endpoint from the previous section (`run-sync-get-dataset-items`) is the simplest tool action: one POST with a video link, one JSON array back — no polling, no pagination.

### Pricing / Cost estimation

This Actor uses the **pay-per-event** pricing model. You are billed for these events, and nothing else:

| Event | When it is charged | Example |
|---|---|---|
| `note-search` | Once per run, for the video note that was searched and fetched — even if the video turns out to have no captions | 1 video = 1 event |
| `transcript-saved` | Once per saved transcript row (one per subtitle language) | A video with Chinese + English captions = 2 events |
| `srt-file-saved` | Once per raw `.srt` file written to the key-value store — only when *Save raw SRT files* is enabled | Two tracks with SRT saving on = 2 events |

The exact per-event prices are shown on the **Pricing** tab of this Actor's page in [Apify Store](https://apify.com/store). Failed notes (expired share links, blocked pages, non-video notes) never trigger `transcript-saved` — you only pay for transcripts you actually receive. SRT files are only charged when you enable the option, so runs that keep transcripts in the dataset never pay for them.

**How much does it cost to scrape RedNote (Xiaohongshu) transcripts?** A single video with two subtitle tracks costs one `note-search` event plus two `transcript-saved` events (add two `srt-file-saved` events if *Save raw SRT files* is on). Check the Pricing tab for current per-event rates and discount tiers.

### Tips and advanced options

- **Always use share links.** The `xsec_token` inside a browser URL expires within hours or days; a share short link (`xhslink.com`) keeps working because RedNote issues a fresh token every time it is opened. If a note suddenly fails with an expired-token error, share it again from the app and use the new link.
- **Rate limits.** Each run scrapes a single video. If you schedule or chain many runs, keep a short interval between them to stay reliable.
- **Pick languages in post-processing.** The Actor fetches every track on the video (`source`, `zh-CN`, `en-US`, …) and writes one row per track. Filter the dataset on the `language` or `track` column to keep only the track you need.
- **SRT for video editing.** Enable *Save raw SRT files* to get subtitle files you can drop straight into a video player or editor.
- **Blocked or empty pages.** If notes return `ERROR`, the most likely cause is an expired `xsec_token` — paste a fresh share link. The Actor already retries blocked pages automatically through residential proxies.

### FAQ, disclaimers, and support

**Is scraping RedNote (Xiaohongshu) legal?** This Actor accesses only publicly served page data and public caption files, without login. You are responsible for how you use the data and for complying with Xiaohongshu's Terms of Service, applicable laws, and the rights of content creators. Do not use this Actor for personal or sensitive data.

**Does it need my RedNote account?** No. The Actor never logs in and never touches endpoints that require an account.

**Which videos have transcripts?** RedNote auto-generates captions only for speech-heavy videos. Music-only clips have no subtitle tracks; such notes come back with status `NO_SUBTITLES`.

**Can it scrape comments or search results?** No — those RedNote surfaces require a login and a private API, which this Actor does not use.

**Does it work with image posts?** Image posts have no spoken content, so they return status `NOT_A_VIDEO`.

Found a bug or need a feature? Please open an issue in the Actor's **Issues** tab on Apify Console. If you need a custom Xiaohongshu or China-market scraping solution, the author is available for custom work.

# Actor input Schema

## `startUrl` (type: `string`):

One RedNote (Xiaohongshu) video to transcribe. <b>Best: paste the share link from the app</b> (Share → Copy link, looks like <code>http://xhslink.com/...</code>) — it never expires. You can paste the whole share message (title, link, emojis); the Actor extracts the link. Full note URLs with an <code>xsec\_token</code> parameter also work, but the token expires — use a fresh copy. Bare note IDs are not supported. One video per run — for more videos, run the Actor again for each.

## `includeSegments` (type: `boolean`):

Include the per-line caption segments with start/end timecodes in the output. Turn off to only keep the plain-text transcript.

## `includePlainText` (type: `boolean`):

Include the full transcript as a single block of plain text.

## `saveSrtFiles` (type: `boolean`):

Also save each fetched subtitle track as a raw <code>.srt</code> file into the run's key-value store.

## Actor input object example

```json
{
  "startUrl": "https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=ABzp0Ud9Y6R-rXTfwiOnqYt-pJwnM7iRRn6gF91oGkXjM=&xsec_source=home_feed",
  "includeSegments": true,
  "includePlainText": true,
  "saveSrtFiles": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `srtFiles` (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 = {
    "startUrl": "https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=ABzp0Ud9Y6R-rXTfwiOnqYt-pJwnM7iRRn6gF91oGkXjM=&xsec_source=home_feed"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/xiaohongshu-transcript-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 = { "startUrl": "https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=ABzp0Ud9Y6R-rXTfwiOnqYt-pJwnM7iRRn6gF91oGkXjM=&xsec_source=home_feed" }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/xiaohongshu-transcript-scraper").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 '{
  "startUrl": "https://www.xiaohongshu.com/explore/6a8732a2000000001700bf41?xsec_token=ABzp0Ud9Y6R-rXTfwiOnqYt-pJwnM7iRRn6gF91oGkXjM=&xsec_source=home_feed"
}' |
apify call hgservices/xiaohongshu-transcript-scraper --silent --output-dataset

```

## MCP server setup

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

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/RwmXt3hz84uRfPVFr/builds/5IEQQKU8gVfsBGYfw/openapi.json