# RedNote Xiaohongshu Profile Scraper (`lightmoon/rednote-profile-scraper`) Actor

Look up public RedNote (Xiaohongshu) creators in bulk: nickname, Red ID, bio, IP location, follower and like counts, plus the notes on their profile with titles, dates and likes. Paste profile links or IDs — no login needed. Flat rows, export to CSV, JSON or Excel.

- **URL**: https://apify.com/lightmoon/rednote-profile-scraper.md
- **Developed by:** [Stable](https://apify.com/lightmoon) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 creator profiles

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.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Look up public RedNote (Xiaohongshu) creators in bulk and get one flat row each:
nickname, Red ID, bio, IP location, follower and like counts — plus the notes
shown on their profile, with titles, dates, likes and cover images.

Give it profile links, or just the profile IDs.

```
https://www.xiaohongshu.com/user/profile/5fec4d4800000000010003dc
5a747a7ce8ac2b215c98d8ef
```

No login, no cookies, no account of your own.

### What one row looks like

A creator, exactly as returned:

```json
{
  "recordType": "profile",
  "userId": "61d2e18e00000000100094e4",
  "redId": "1699116963",
  "nickname": "洛杉矶大通租车",
  "profileUrl": "https://www.xiaohongshu.com/user/profile/61d2e18e00000000100094e4",
  "bio": "洛杉矶安大略24小时租车行，成立于2016年，Ontario租车免费接机…",
  "ipLocation": "美国",
  "tags": "旅行博主, 北京邮电大学",
  "avatarUrl": "https://sns-avatar-qc.xhscdn.com/avatar/645e30c3e4585fb5abee2642.jpg",
  "followersCount": 1000,
  "followersCountText": "1K+",
  "followingCount": 1000,
  "followingCountText": "1K+",
  "likesAndCollectsCount": 10000,
  "likesAndCollectsCountText": "10K+",
  "notesReturned": 31,
  "moreNotesAvailable": true,
  "notesTotalLikes": 1057,
  "latestNoteAt": "2026-08-14T05:07:32+00:00",
  "oldestNoteAt": "2026-08-03T17:54:27+00:00",
  "scrapedAt": "2026-08-14T06:05:21+00:00"
}
```

And their most recent note:

```json
{
  "recordType": "note",
  "userId": "61d2e18e00000000100094e4",
  "redId": "1699116963",
  "nickname": "洛杉矶大通租车",
  "notePosition": 1,
  "noteTitle": "洛杉矶租车太难了！拿了一把真枪当押金！",
  "noteType": "video",
  "postedAt": "2026-08-05T03:50:08+00:00",
  "likesCount": 76,
  "likesCountText": "76",
  "isPinned": true,
  "coverUrl": "http://sns-webpic-qc.xhscdn.com/…/nc_n_nwebp_mw_1",
  "coverWidth": 720,
  "coverHeight": 1280,
  "scrapedAt": "2026-08-14T06:05:21+00:00"
}
```

Every row is flat — no nested objects — so CSV and Excel exports open correctly
with no post-processing.

### Two kinds of row, and you choose

| Setting | What lands in the dataset |
|---|---|
| **Creators** *(default)* | One row per profile. 23 columns. |
| **Notes** | One row per note, with the creator's name and Red ID repeated on each. 17 columns. |
| **Both** | Both, in one dataset. The `recordType` column says which, and the Output tab shows them as two tables. |

### Fields

**Creator row — 23 columns**

| Field | What it is |
|---|---|
| `userId`, `redId` | The ID in the profile URL, and the Red ID shown on the page |
| `nickname`, `bio`, `avatarUrl` | As displayed |
| `gender` | `male` / `female`, read from the badge on the profile. Absent when no badge |
| `ipLocation` | The region RedNote shows next to the account |
| `tags` | The profile's own labels — often the creator's stated niche, city or university, e.g. `旅行博主, 北京邮电大学` |
| `followersCount`, `followingCount`, `likesAndCollectsCount` | Numbers to sort by, but bucketed by RedNote — **read the section below before ranking on them** |
| `followersCountText`, `followingCountText`, `likesAndCollectsCountText` | The same figures exactly as displayed |
| `notesReturned` | How many notes came back for this creator |
| `moreNotesAvailable` | `true` when the creator has posted more than the page shows |
| `notesTotalLikes` | Likes across the notes returned. **The most discriminating number in the row** — see below |
| `latestNoteAt`, `oldestNoteAt` | How recently, and for how long, they have been posting |
| `profileUrl`, `inputEntry`, `scrapedAt` | Where it came from, what you pasted, when it was read |

**Note row — 17 columns**

| Field | What it is |
|---|---|
| `notePosition` | Where it sits in the grid, 1 first |
| `noteTitle` | The title as displayed |
| `noteType` | `image` or `video` |
| `postedAt` | When it was published |
| `likesCount`, `likesCountText` | Number and displayed text |
| `isPinned` | Present when the creator has pinned it to the top |
| `coverUrl`, `coverWidth`, `coverHeight` | The grid thumbnail |
| `userId`, `redId`, `nickname`, `profileUrl` | Repeated, so the notes table stands alone |

#### Read this before you sort by followers

RedNote does not show a visitor an exact follower count. Measured across live
profiles, it shows one of three buckets and nothing finer:

| What the profile shows | What it means |
|---|---|
| `10+` | under about a thousand |
| `1K+` | roughly one to ten thousand |
| `10K+` | **ten thousand or more — and that is the top bucket** |

So `followersCount` separates a micro creator from a mid one, and it **cannot
separate a 15,000-follower creator from a celebrity with millions.** Both read
`10K+`. The same applies to `likesAndCollectsCount`. Any tool reading this page
is working from the same three buckets, whatever it reports.

**Use the notes for reach instead, because those numbers are real.** Per-note
likes are exact up to about ten thousand and rounded in Chinese units above it
(`2846`, `1.6万`, `10万+`), and `notesTotalLikes` adds them up. In one measured
run that column read **1,057** for a small local business and **860,827** for a
well-known creator — three orders of magnitude apart, where the follower column
showed `1K+` and `10K+`.

Every count comes back twice: `…Text` is the string exactly as a visitor sees
it, and the plain column is that string as a number to sort by, always read as a
**floor** — `10K+` becomes `10000`, `1.6万` becomes `16000`. A count the page
hides is left empty rather than written as zero, so a creator who hides their
numbers never sorts below one who has none.

### Recipes

**Vet a list of creators before an outreach campaign.** Paste the profile links,
export the creator table, and rank by `notesTotalLikes` — the follower column is
bucketed by RedNote and tops out, so likes are what actually separates one
creator from another. Then read `bio`, `tags` and `ipLocation` to see who is in
your market: `tags` is where the profile's own labels live, and it is often the
creator's stated niche or where they studied.

**Check whether an account is alive.** `latestNoteAt` and `oldestNoteAt` tell
you at a glance whether someone posts weekly or stopped a year ago.
`notesReturned` and `moreNotesAvailable` say whether the account has a real body
of work behind it.

**Find the creators worth their price.** `notesTotalLikes` divided by
`notesReturned` is average likes per post — the number that decides a placement.
A creator sitting in the `1K+` bucket with high likes per post is usually a
better buy than one in `10K+` with low ones.

**Track a roster over time.** Schedule it on the same profile list and keep the
runs; `scrapedAt` is on every row, so follower growth is a subtraction.

### What it costs

You pay per row stored, at two rates. A *Creators* run is billed entirely at the
profile rate and never for notes you did not ask for.

| Your Apify plan | Per 1,000 creator profiles | Per 1,000 notes |
|---|---|---|
| Free, Starter | $12.00 | $1.35 |
| Scale | $7.99 | $0.90 |
| Business and above | **$4.50** | **$0.50** |

**What a run actually costs.** One creator in *Creators* mode is $0.0045 on the
lowest rate. One creator in *Both* mode — the profile plus the ~26 notes their
page carries — is about $0.018. A thousand creators vetted with their grids is
under $18.

**On the free plan**, Apify gives you $5 of platform credit each month, and that
is what you use to try this out — there is no separate trial to sign up for. It
buys about **400 creator profiles** a month in *Creators* mode, or about **100
creators with their notes** in *Both* mode.

A profile that cannot be read costs nothing, duplicates in your list are charged
once, and the run stops the moment it reaches whatever spending cap you set
on it.

### Limits

Stated plainly, because they decide whether this is the right tool:

- **It returns the notes shown on the profile — about 30 — not the full
  archive.** RedNote renders the first screen of the grid into the page and
  keeps the rest behind a request this Actor does not make. When a creator has
  more, `moreNotesAvailable` says so.
- **Notes come back without a link to the note.** RedNote does not put note IDs
  into the profile page, and the tokens a working link needs are not there
  either. You get the title, date, likes, type and cover image — not a URL.
- **Follower counts arrive in three buckets and stop at `10K+`.** That is what
  RedNote shows a visitor, not a limit of this Actor, and it means the follower
  column cannot rank large creators against each other. Use `notesTotalLikes`
  for that — see the counts section above.
- **Comments are not available.** Neither the text nor the count is on the
  profile page.
- **The input is a profile URL or the profile ID from it.** The Red ID — the
  number displayed on the profile as the creator's handle — is a different
  identifier and cannot be used to open a profile; paste it and the run says so
  and skips that entry. There is no lookup by nickname.
- **Public profiles only.** Nothing that needs a login, and no follower or
  following lists.
- **Restricted and deleted accounts** are reported as failures in the run
  summary rather than returned as empty rows.

### Output

Every run writes a flat dataset, exportable as JSON, CSV, Excel, XML or HTML,
and readable through the Apify API. The Output tab shows two ready-made tables —
**Creators** and **Notes** — plus **All fields**.

The run also writes a `RUN_SUMMARY` record: how many profiles were read, which
entries could not be used and why, and which ones the site refused. Worth
reading when a run returns fewer rows than you pasted in.

### FAQ

#### Do I need a RedNote account or cookies?

No. Nothing here needs a login.

#### Why do two very different creators both show `10K+` followers?

Because that is the largest bucket RedNote shows a visitor. There is no finer
figure on the page to return. Rank by `notesTotalLikes` instead — those numbers
come from the notes themselves and are far more discriminating.

#### Why is `followersCount` 10 when the profile clearly has more?

Because the profile displayed `10+`, and the number is the floor of what was
shown. `followersCountText` keeps the original string.

#### Can I get a creator's full posting history?

Not from this Actor. It returns the notes RedNote puts on the profile page —
about 30 — and sets `moreNotesAvailable` when there are more.

#### Can I get the URL of a note?

No. RedNote does not publish note IDs on the profile page, so there is nothing
to build a reliable link from.

#### What happens if I paste something that is not a profile?

The entry is skipped with a message naming what was wrong, the rest of the run
continues, and the skipped entries are listed in `RUN_SUMMARY`. Duplicates in
your list are collapsed, so the same creator is fetched — and billed — once.

#### How many profiles can I do in one run?

There is no fixed cap. Profiles are read one at a time and at a deliberate pace,
so a few hundred is a run of some minutes rather than seconds.

#### What does a row cost if the profile is empty?

Nothing. Only stored rows are billed.

#### How much does it cost to vet 10,000 creators?

$45 on the lowest rate in *Creators* mode, or about $177 in *Both* mode, where
each creator also brings the roughly 26 notes on their page. Set a spending cap
on the run if you want a hard ceiling.

### Other scrapers we maintain

Same engine, same pricing model, same promise: flat rows, stated limits,
and no charge for a row that came back empty.

| | |
|---|---|
| **[Google Maps Contact Scraper](https://apify.com/lightmoon/google-maps-contact-scraper)** | Local businesses by category and city — phone, website, split address and opening hours. |
| **[Local Business Phone Scraper](https://apify.com/lightmoon/local-business-phone-scraper)** | The same job from directory sources, with Better Business Bureau accreditation on the row. |
| **[YouTube Influencer Scraper](https://apify.com/lightmoon/youtube-influencer-scraper)** | Creators by niche, with the website and socials they publish and a subscriber filter. |
| **[Telegram Channel Messages Scraper](https://apify.com/lightmoon/telegram-messages-scraper)** | Posts from public channels — text, views, reactions and media links, no account needed. |
| **[Threads Hashtag Scraper](https://apify.com/lightmoon/threads-hashtag-scraper)** | Threads posts by hashtag or keyword, with author, engagement and links. |
| **[ATS Jobs Scraper](https://apify.com/lightmoon/ats-jobs-scraper)** | Open roles straight from company career pages on Greenhouse, Lever, Ashby and Workday. |

# Actor input Schema

## `profiles` (type: `array`):

One per line. Paste the profile URL straight from the address bar, or just the 24-character profile id from the end of it. The number shown on the profile as the creator's Red ID is a different identifier and cannot be used here — open the profile and copy the URL instead.

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

Creator rows, note rows, or both in one dataset. When both are returned, every row says which it is in the `recordType` column and the Output tab shows them as separate tables.

## `maxNotesPerProfile` (type: `integer`):

Caps how many of a creator's notes are returned. The profile page carries the first screen of the grid — about 30 notes — and that is the most this can return, so a creator with more will show `moreNotesAvailable` set. Set 0 for all of them.

## Actor input object example

```json
{
  "profiles": [
    "https://www.xiaohongshu.com/user/profile/5fec4d4800000000010003dc",
    "5a747a7ce8ac2b215c98d8ef"
  ],
  "resultType": "profiles",
  "maxNotesPerProfile": 0
}
```

# Actor output Schema

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

No description

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

No description

## `all` (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 = {
    "profiles": [
        "https://www.xiaohongshu.com/user/profile/5fec4d4800000000010003dc",
        "5a747a7ce8ac2b215c98d8ef"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lightmoon/rednote-profile-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 = { "profiles": [
        "https://www.xiaohongshu.com/user/profile/5fec4d4800000000010003dc",
        "5a747a7ce8ac2b215c98d8ef",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lightmoon/rednote-profile-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 '{
  "profiles": [
    "https://www.xiaohongshu.com/user/profile/5fec4d4800000000010003dc",
    "5a747a7ce8ac2b215c98d8ef"
  ]
}' |
apify call lightmoon/rednote-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lightmoon/rednote-profile-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/GdQIkh4n0Xek4lfQr/builds/VMy8ABvSYXUpNvnjp/openapi.json