# RedNote (Xiaohongshu) Scraper — Trending Notes & Creators (`logiover/rednote-xiaohongshu-scraper`) Actor

Keyless RedNote / Xiaohongshu (小红书) trending scraper. Sweep all 12 discovery channels for trending notes: title, likes, cover image, note URL + creator profile leads. No cookie, no login, no API key.

- **URL**: https://apify.com/logiover/rednote-xiaohongshu-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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 (Xiaohongshu) Scraper — Trending Notes & Creators

Discover what's trending on **RedNote / Xiaohongshu (小红书)** right now — **no cookie, no login, no API key**. Sweep dozens of discovery channels and export **500+ trending notes per run** with titles, like counts, cover images, note URLs and creator profile leads to JSON, CSV or Excel.

RedNote (Xiaohongshu, "Little Red Book", RED) is one of China's largest social-commerce and lifestyle platforms, with 300M+ monthly users and a huge global audience since 2025. This scraper turns its live discovery feeds into clean, structured data for **trend tracking, creator (KOL) discovery, content research and marketing intelligence** — the honest, genuinely keyless way.

---

### What does the RedNote Scraper do?

This actor fetches RedNote's **server-rendered `/explore` pages** and parses the inline `window.__INITIAL_STATE__` JSON that RedNote ships with every page load. That embedded state contains the live **`feed.feeds[]`** array — the exact note cards RedNote's own website renders. No headless browser, no signature, no cookie: just fast HTTP requests via `got-scraping`.

RedNote exposes dozens of discovery **channels** (`?channel_type=...`) — Recommend, Fashion, Food, Cosmetics, Movie & TV, Career, Love, Household, Gaming, Travel, Fitness, Video, Beauty, Parenting, Tech, Car, Pets, Sports, Music, Photography, Finance, Anime, Astrology, Jewelry and many more. Each channel returns ~24 note cards, channels barely overlap, and **every request refreshes with brand-new notes** (verified 0% overlap over repeated passes). The scraper loops the channels in a multi-cycle round-robin, **dedupes by note ID**, and accumulates **500+ unique trending notes per run** (bounded by `maxResults`, default 500). Each note yields its title, like count, cover image, public note URL, and the creator's handle + profile URL — a ready-made lead list of trending creators.

---

### Who is it for?

- **Social media & content marketers** tracking what resonates on RedNote this week.
- **Trend and market researchers** monitoring lifestyle, beauty, food, travel and fashion trends in the Chinese market.
- **Influencer / KOL discovery teams** building lists of active, trending creators to partner with.
- **E-commerce and brand teams** watching content formats, hooks and cover styles that drive engagement.
- **Data engineers & analysts** who need a keyless, scriptable feed of RedNote discovery data for dashboards or ML.

---

### Use cases

- **Trend radar** — run the trending sweep daily and diff results to see which topics, hashtags-in-titles and formats are heating up.
- **Creator lead generation** — export creator nicknames + profile URLs across every channel to seed influencer outreach.
- **Content benchmarking** — study the titles and cover images of the highest-liked notes per channel for creative inspiration.
- **Vertical monitoring** — pull just the Beauty (Cosmetics), Food, Travel or Fashion channel to track a specific niche.
- **Engagement analytics** — aggregate like counts per channel over time to measure category momentum.

---

### Why use this RedNote Scraper?

- 🔓 **Genuinely keyless** — no cookie, no login, no account, no API key. Competitors that require you to paste your own RedNote cookie put your account at risk; this one never does.
- 🌊 **All-channel sweep with dedupe** — one run covers dozens of discovery channels, re-loops as the feed refreshes, and returns 500+ unique notes, not a single page.
- 👥 **Creator lead URLs** — every note includes the creator's handle and profile URL, so results double as a trending-creator list.
- 🔢 **Clean numeric data** — like counts are real numbers (RedNote's "1.4万" / "10万+" are parsed to 14000 / 100000), with the original string kept too.
- 🖼️ **Media & links** — cover image (full + preview), image URLs, and public note URLs with valid access tokens.
- 📤 **Export anywhere** — download as JSON, CSV or Excel, or push to Google Sheets, Slack, a database, or any app via the Apify API — **pay per result**.

---

### What data can you extract?

Each row is one trending note. Fields:

| Field | Type | Description |
|---|---|---|
| `noteId` | string | RedNote note ID |
| `type` | string | `normal` (image note) or `video` |
| `title` | string | Note display title |
| `likedCount` | number | Like count as an integer (parsed from RedNote's formatted string) |
| `likedCountText` | string | Original RedNote like string, e.g. `10万+`, `1.4万` |
| `channel` | string | Source channel key, e.g. `homefeed.food_v3` |
| `channelName` | string | Human channel name, e.g. `Food` |
| `coverImage` | string | Full-resolution cover image URL |
| `coverImagePreview` | string | Low-res cover preview URL |
| `coverWidth` / `coverHeight` | number | Cover dimensions in pixels |
| `images` | array | Cover-derived image URLs |
| `noteUrl` / `url` | string | Public note URL (includes `xsec_token`) |
| `xsecToken` | string | Note access token |
| `userId` | string | Creator user ID |
| `nickname` | string | Creator nickname / handle |
| `avatar` | string | Creator avatar image URL |
| `userUrl` | string | Creator profile URL (lead) |
| `creatorXsecToken` | string | Creator access token |
| `author` | object | Nested creator object: `userId`, `nickname`, `avatar`, `xsecToken`, `profileUrl` |
| `channelName`, `_mode`, `scrapedAt` | string | Run metadata (channel, `trending`/`channel`, ISO timestamp) |

#### Example output

```json
{
  "noteId": "643ea89d000000001203ff96",
  "type": "normal",
  "title": "Chengdu 3-day food guide — best hotpot spots",
  "likedCount": 14000,
  "likedCountText": "1.4万",
  "channel": "homefeed.food_v3",
  "channelName": "Food",
  "coverImage": "https://sns-webpic-qc.xhscdn.com/....!nc_n_webp_mw_1",
  "coverImagePreview": "https://sns-webpic-qc.xhscdn.com/....!nc_n_webp_prv_1",
  "coverWidth": 1000,
  "coverHeight": 1334,
  "images": ["https://sns-webpic-qc.xhscdn.com/....!nc_n_webp_mw_1"],
  "noteUrl": "https://www.xiaohongshu.com/explore/643ea89d000000001203ff96?xsec_token=ABBub0mt...&xsec_source=pc_feed",
  "url": "https://www.xiaohongshu.com/explore/643ea89d000000001203ff96?xsec_token=ABBub0mt...&xsec_source=pc_feed",
  "xsecToken": "ABBub0mt0IDWHkm02Gor3cMMvewjnfNSW5iIcUe0A0NPw=",
  "userId": "63e746880000000026005b93",
  "nickname": "偷懒的猪猪",
  "avatar": "https://sns-avatar-qc.xhscdn.com/avatar/63f72625a2fd9b4da9e2e21e.jpg",
  "userUrl": "https://www.xiaohongshu.com/user/profile/63e746880000000026005b93?xsec_token=...",
  "creatorXsecToken": "ABBub0mt0IDWHkm02Gor3cMMvewjnfNSW5iIcUe0A0NPw=",
  "author": {
    "userId": "63e746880000000026005b93",
    "nickname": "偷懒的猪猪",
    "avatar": "https://sns-avatar-qc.xhscdn.com/avatar/63f72625a2fd9b4da9e2e21e.jpg",
    "xsecToken": "ABBub0mt0IDWHkm02Gor3cMMvewjnfNSW5iIcUe0A0NPw=",
    "profileUrl": "https://www.xiaohongshu.com/user/profile/63e746880000000026005b93?xsec_token=..."
  },
  "_mode": "trending",
  "scrapedAt": "2026-07-24T16:40:00.000Z"
}
````

***

### How to use

#### Option A — Trending sweep (default, recommended)

The simplest way: leave everything at its default and press **Start**. The scraper sweeps all channels, re-loops as the feed refreshes, dedupes, and returns up to `maxResults` (default 500) unique trending notes.

```json
{
  "mode": "trending",
  "maxResults": 500
}
```

An empty input `{}` does exactly the same thing.

#### Option B — Single channel

Pick one channel to monitor a specific niche (e.g. Beauty or Food):

```json
{
  "mode": "channel",
  "channel": "homefeed.cosmetics_v3",
  "maxResults": 200
}
```

Steps:

1. Click **Try for free / Start**.
2. Choose **Mode** — `trending` (all channels) or `channel` (one channel).
3. For `channel` mode, pick a **Channel** from the dropdown.
4. Set **Max results** (default 500).
5. Press **Start**, then download JSON / CSV / Excel when the run finishes.

***

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `trending` | `trending` sweeps all channels & dedupes; `channel` pulls one channel. |
| `channel` | select | `homefeed_recommend` | Which single channel to pull in `channel` mode (48 options). |
| `maxResults` | integer | `500` | Max unique notes to collect (1–5000). |
| `proxy` | object | Residential | Proxy configuration. Residential recommended. |

Full input example:

```json
{
  "mode": "trending",
  "maxResults": 500,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

***

### Output example

```json
{
  "noteId": "63e5dcbc000000001d020324",
  "type": "video",
  "title": "领证全过程来啦！",
  "likedCount": 76000,
  "likedCountText": "7.6万",
  "channel": "homefeed.fashion_v3",
  "channelName": "Fashion",
  "coverImage": "https://sns-webpic-qc.xhscdn.com/....!nc_n_webp_mw_1",
  "coverImagePreview": "https://sns-webpic-qc.xhscdn.com/....!nc_n_webp_prv_1",
  "noteUrl": "https://www.xiaohongshu.com/explore/63e5dcbc000000001d020324?xsec_token=ABRhnpAF...&xsec_source=pc_feed",
  "nickname": "小鱼海棠",
  "userId": "5af954074eacab1f284d8d90",
  "userUrl": "https://www.xiaohongshu.com/user/profile/5af954074eacab1f284d8d90?xsec_token=...",
  "_mode": "trending",
  "scrapedAt": "2026-07-24T16:40:00.000Z"
}
```

***

### Tips for best results

- **Keep residential proxies on.** RedNote geoblocks some datacenter ranges; residential IPs are the reliable choice.
- **Start small, then scale.** Run with a small `maxResults` to validate, then raise it (default 500) for bigger pulls.
- **Run on a schedule.** Trending feeds change constantly — a daily or hourly schedule captures momentum over time.
- **Dedupe across runs** on `noteId` in your warehouse if you want a rolling unique set.
- **Watch `likedCountText`** for `10万+` values — RedNote caps the displayed number, so `likedCount` will read `100000` for anything above 100k.
- **Use `channel` mode for niche monitoring** — one channel gives deeper coverage of a single vertical.
- **Cover images are CDN links** (`sns-webpic-qc.xhscdn.com`) and may expire; download promptly if you need to archive them.
- **Creator leads**: `userUrl` + `nickname` across a sweep is an instant trending-creator shortlist.
- **Bigger `maxResults` = more channel cycles.** The run stops gracefully at a ~4-minute time budget and keeps whatever it collected.

***

### Integrations

Connect RedNote data to your stack with a few clicks:

- **Google Sheets** — auto-append every run's notes to a sheet.
- **Slack** — notify a channel when a run finishes.
- **Zapier / Make** — trigger downstream workflows on new results.
- **Webhooks** — POST results to your own endpoint.
- **Schedule** — run the trending sweep hourly or daily from the Apify scheduler.

***

### API usage

Run the actor from anywhere with the Apify API. Get your token from the Apify Console.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~rednote-xiaohongshu-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "trending", "maxResults": 300 }'
```

**Node.js**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/rednote-xiaohongshu-scraper').call({
  mode: 'trending',
  maxResults: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/rednote-xiaohongshu-scraper").call(
    run_input={"mode": "trending", "maxResults": 300}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["likedCount"])
```

***

### Use with AI agents (MCP)

This actor works as a tool for AI agents via the Apify MCP server. Point your agent (Claude, ChatGPT, or any MCP-compatible client) at the Apify MCP endpoint and it can call this scraper on demand — for example: *"Get the top 100 trending RedNote notes about food and list the creators with the most likes."* The agent runs the actor, reads the dataset, and reasons over the structured results.

***

### FAQ

#### Is this RedNote scraper really keyless — no cookie or login?

Yes. It reads RedNote's public server-rendered `/explore` HTML (the `__INITIAL_STATE__` blob) that anyone gets by visiting the site. You never provide a cookie, account or API key. This is the core difference from cookie-based scrapers.

#### What data can it collect?

Trending/discovery notes across dozens of channels: note ID, title, type, like count, cover image, note URL, and the creator's handle, ID and profile URL.

#### What can't it collect (limits / scope)?

Full note body text, comments, hashtags, exact publish timestamps, keyword search results, and detailed profile stats (followers, etc.) all require a logged-in cookie and RedNote's signed API — those are **out of scope** for this keyless actor. Honest scope = trust.

#### How many notes can I get per run?

**500+ easily** (default 500). Because the feed refreshes on every request and dozens of channels barely overlap, the scraper loops and dedupes to reach your `maxResults` (up to 5000, bounded by a ~4-minute time budget). A single full sweep of all channels already yields well over a thousand unique notes.

#### Why did I get fewer results than `maxResults`?

The run hit its time budget, or the residential IP pool was briefly rate-limited. Re-run (fresh IPs) or lower `maxResults`. Feeds also naturally have a finite pool of fresh notes at any moment.

#### Why are some fields null?

Fields that only exist on the note-detail page (full `description`, `publishTime`, `commentCount`, etc.) are null in this keyless feed by design — they're not present in the discovery SSR data.

#### Can I get a note's or creator's full page?

Yes — the `noteUrl` and `userUrl` include valid `xsec_token`s, so you can open them in a browser. Extracting their full content requires a logged-in session and is out of scope here.

#### Why do I need a proxy?

RedNote geoblocks some datacenter IP ranges. The default residential proxy keeps requests reliable. Never force the datacenter-only group.

#### How do I export the data?

Download from the run's Dataset tab as JSON, CSV, Excel or XML, or pull it via the Apify API / client in your own code.

#### Is scraping RedNote legal?

This tool collects only **publicly available** data that RedNote serves to any visitor. You are responsible for using the data in line with RedNote's terms, applicable laws (e.g. GDPR), and for not collecting private personal information. See below.

#### How often is the actor updated?

It's maintained against RedNote's public `/explore` structure. If the site changes its embedded state format, the parser is updated. See the Changelog.

#### Can I monitor just one topic, like beauty or travel?

Yes — use `channel` mode and pick the matching channel (Cosmetics, Travel, Food, Fashion, etc.).

***

### Is it legal?

This scraper accesses only **publicly available** content that RedNote / Xiaohongshu serves to any unauthenticated visitor — the same data shown on the public `/explore` pages. It does not bypass authentication, does not use anyone's account, and does not collect private data. You are responsible for complying with RedNote's Terms of Service, robots directives, and all applicable data-protection laws (including GDPR/PIPL) when you store or process the results. Do not use scraped data to harass individuals or infringe rights. If you are unsure, consult a legal professional.

***

### Related scrapers

- **TikTok Scraper** — trending videos, creators and hashtags.
- **Instagram Scraper** — posts, profiles and reels.
- **Weibo Scraper** — Chinese microblog trends and posts.
- **Pinterest Scraper** — pins, boards and visual trends.

Keywords: rednote scraper, xiaohongshu scraper, 小红书 scraper, little red book scraper, RED app data, rednote trending, xiaohongshu trending notes, rednote creator discovery, xiaohongshu api alternative, scrape rednote without cookie, keyless xiaohongshu scraper, rednote data export.

# Actor input Schema

## `mode` (type: `string`):

trending = sweep all discovery channels and dedupe (recommended). channel = pull one specific channel only.

## `channel` (type: `string`):

Which single RedNote discovery channel to pull when Mode = channel. Ignored in trending mode. The feed refreshes on every request, so the scraper re-fetches this one channel until it reaches Max results.

## `maxResults` (type: `integer`):

Maximum number of unique notes to collect. The scraper loops channels (the feed refreshes each request) and dedupes by note ID until it reaches this number or the ~4-minute time budget. A single trending run comfortably returns 500+ unique notes.

## `proxy` (type: `object`):

Residential proxy is recommended — RedNote geoblocks some datacenter ranges. Leave as-is for best reliability.

## Actor input object example

```json
{
  "mode": "trending",
  "channel": "homefeed_recommend",
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `noteId` (type: `string`):

RedNote note ID

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

normal (image) or video

## `title` (type: `string`):

Note display title

## `likedCount` (type: `string`):

Like count (number)

## `likedCountText` (type: `string`):

Original XHS like string e.g. 10万+

## `channel` (type: `string`):

Source channel key

## `channelName` (type: `string`):

Human channel name

## `coverImage` (type: `string`):

Cover image URL

## `coverImagePreview` (type: `string`):

Low-res cover preview URL

## `noteUrl` (type: `string`):

Public note URL (with xsec\_token)

## `xsecToken` (type: `string`):

Note access token

## `nickname` (type: `string`):

Creator nickname

## `userId` (type: `string`):

Creator user ID

## `userUrl` (type: `string`):

Creator profile URL (lead)

## `avatar` (type: `string`):

Creator avatar URL

## `scrapedAt` (type: `string`):

Scrape timestamp (ISO)

# 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 = {
    "maxResults": 500,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/rednote-xiaohongshu-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 = {
    "maxResults": 500,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/rednote-xiaohongshu-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 '{
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call logiover/rednote-xiaohongshu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote (Xiaohongshu) Scraper — Trending Notes & Creators",
        "description": "Keyless RedNote / Xiaohongshu (小红书) trending scraper. Sweep all 12 discovery channels for trending notes: title, likes, cover image, note URL + creator profile leads. No cookie, no login, no API key.",
        "version": "2.1",
        "x-build-id": "BGB3eFpPwLXA4Gru5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~rednote-xiaohongshu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-rednote-xiaohongshu-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/logiover~rednote-xiaohongshu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-rednote-xiaohongshu-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/logiover~rednote-xiaohongshu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-rednote-xiaohongshu-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "trending",
                            "channel"
                        ],
                        "type": "string",
                        "description": "trending = sweep all discovery channels and dedupe (recommended). channel = pull one specific channel only.",
                        "default": "trending"
                    },
                    "channel": {
                        "title": "Channel (only for 'channel' mode)",
                        "enum": [
                            "homefeed_recommend",
                            "homefeed.fashion_v3",
                            "homefeed.food_v3",
                            "homefeed.cosmetics_v3",
                            "homefeed.movie_and_tv_v3",
                            "homefeed.career_v3",
                            "homefeed.love_v3",
                            "homefeed.household_product_v3",
                            "homefeed.gaming_v3",
                            "homefeed.travel_v3",
                            "homefeed.fitness_v3",
                            "homefeed.video_v3",
                            "homefeed.beauty_v3",
                            "homefeed.makeup_v3",
                            "homefeed.parenting_v3",
                            "homefeed.baby_v3",
                            "homefeed.wedding_v3",
                            "homefeed.emotion_v3",
                            "homefeed.tech_v3",
                            "homefeed.digital_v3",
                            "homefeed.electronics_v3",
                            "homefeed.car_v3",
                            "homefeed.pets_v3",
                            "homefeed.reading_v3",
                            "homefeed.education_v3",
                            "homefeed.sports_v3",
                            "homefeed.outdoors_v3",
                            "homefeed.music_v3",
                            "homefeed.dance_v3",
                            "homefeed.photography_v3",
                            "homefeed.design_v3",
                            "homefeed.home_decor_v3",
                            "homefeed.furniture_v3",
                            "homefeed.health_v3",
                            "homefeed.finance_v3",
                            "homefeed.investment_v3",
                            "homefeed.cooking_v3",
                            "homefeed.recipe_v3",
                            "homefeed.anime_v3",
                            "homefeed.comic_v3",
                            "homefeed.science_v3",
                            "homefeed.astrology_v3",
                            "homefeed.jewelry_v3",
                            "homefeed.luxury_v3",
                            "homefeed.plant_v3",
                            "homefeed.gardening_v3",
                            "homefeed.diy_v3",
                            "homefeed.handmade_v3"
                        ],
                        "type": "string",
                        "description": "Which single RedNote discovery channel to pull when Mode = channel. Ignored in trending mode. The feed refreshes on every request, so the scraper re-fetches this one channel until it reaches Max results.",
                        "default": "homefeed_recommend"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique notes to collect. The scraper loops channels (the feed refreshes each request) and dedupes by note ID until it reaches this number or the ~4-minute time budget. A single trending run comfortably returns 500+ unique notes.",
                        "default": 500
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended — RedNote geoblocks some datacenter ranges. Leave as-is for best reliability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
