# Xiaohongshu Profiles Scraper (`automation-lab/rednote-xiaohongshu-profile-scraper`) Actor

Extract public Xiaohongshu creator identity, biographies, tags, audience metrics, and recent note context from profile URLs or user IDs.

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

## Pricing

from $2.40 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Xiaohongshu Profiles Scraper

Extract **Xiaohongshu profiles** from public creator URLs or user IDs.

Turn a creator list into clean records with nickname, Red ID, biography, avatar, public profile tags, follower and following counts, combined interaction signals, and optional recent note context.

Use the results for influencer discovery, creator-list enrichment, campaign research, and repeat profile monitoring.

### What does Xiaohongshu Profiles Scraper do?

The Actor accepts public `xiaohongshu.com/user/profile/...` URLs and 24-character creator IDs.

It returns one dataset row for each distinct public profile it can read.

Each row preserves the canonical profile URL and stable user ID for downstream joins.

Visible Chinese shorthand counts such as `1万+` are normalized to integers.

Recent public note cards can be nested in the profile row without creating a second dataset.

The Actor does not log in or request private account data.

### Who is it for?

**Influencer marketers** can enrich a shortlist before campaign outreach.

**Brand research teams** can compare public audience and interaction signals across creators.

**Agencies** can refresh stored creator records on an Apify schedule.

**Data teams** can export normalized profile snapshots to a spreadsheet, CRM, or warehouse.

**Analysts** can keep note titles and visible likes beside creator-level metrics for campaign context.

### Why use this Actor?

Xiaohongshu profile pages mix creator details, localized counts, and note cards inside application state.

This Actor turns that public page state into stable, typed JSON.

It supports both URL-first research and ID-first enrichment workflows.

Duplicate IDs are fetched and charged once per run.

Failed, challenged, and invalid targets are not charged as profile items.

A run-summary key-value record reports concise failures without polluting the primary profile dataset.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `profileUrl` | Canonical public Xiaohongshu profile URL |
| `userId` | Stable 24-character creator ID |
| `nickname` | Public display name |
| `redId` | Public-facing RedNote identifier when exposed |
| `bio` | Public biography or description |
| `location` | Public IP location label when exposed |
| `gender` | Public source gender code normalized to a label when present |
| `avatarUrl` | Public avatar image URL |
| `followerCount` | Visible follower count normalized to an integer |
| `followingCount` | Visible following count normalized to an integer |
| `interactionCount` | Visible combined likes-and-collections signal |
| `tags` | Public labels such as profession, category, or location |
| `recentNotes` | Optional recent note titles, types, timestamps, covers, and visible likes |
| `scrapedAt` | UTC timestamp of the profile snapshot |

Fields that Xiaohongshu does not expose for a profile are omitted.

The Actor does not guess missing metrics.

### Getting started

1. Open the Actor input page.
2. Paste one or more public profile URLs into **Profile URLs**.
3. Alternatively, add 24-character IDs under **Creator user IDs**.
4. Choose whether to include recent note context.
5. Set a small **Maximum profiles** value for your first run.
6. Run the Actor.
7. Open the **Creator profiles** dataset view.
8. Export the rows as JSON, CSV, Excel, XML, or RSS.

The prefilled profile URL is a real public input suitable for a first smoke test.

### Input parameters

#### Profile URLs

`profileUrls` accepts request-list entries such as:

```text
https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11
```

Only canonical public Xiaohongshu profile URLs are accepted.

Tracking query parameters are removed from the output URL.

#### Creator user IDs

`userIds` accepts strings containing exactly 24 hexadecimal characters.

Use this route when a CRM, sheet, or previous dataset already stores creator IDs.

URLs and IDs can be combined in one run.

Duplicates resolve to one profile row.

#### Limits and note context

`maxProfiles` limits distinct valid creators and supports values from 1 to 500.

`includeRecentNotes` defaults to `true`.

`maxRecentNotesPerProfile` accepts 0 to 30 and defaults to 10.

Set `includeRecentNotes` to `false` or the note limit to 0 for lightweight profile-only enrichment.

#### Proxy configuration

Direct public HTML is the primary route.

The default configuration keeps one SHADER datacenter identity available as a bounded fallback when direct access is challenged or transiently unavailable.

No residential or browser fallback runs automatically.

You can disable Apify Proxy in advanced input when your environment does not need fallback delivery.

### Output example

The following anonymized record mirrors current output types and structure:

```json
{
  "profileUrl": "https://www.xiaohongshu.com/user/profile/abcdef0123456789abcdef01",
  "userId": "abcdef0123456789abcdef01",
  "nickname": "Example Creator",
  "redId": "example_creator_88",
  "bio": "Travel and food creator sharing public recommendations.",
  "location": "Shanghai",
  "gender": "female",
  "avatarUrl": "https://sns-avatar-qc.xhscdn.com/avatar/example-profile-image",
  "followerCount": 12000,
  "followingCount": 120,
  "interactionCount": 45000,
  "tags": [{ "name": "Travel creator", "type": "profession" }],
  "recentNotes": [
    {
      "title": "A public note title",
      "type": "normal",
      "publishedAt": "2025-01-15T12:00:00.000Z",
      "coverUrl": "https://sns-webpic-qc.xhscdn.com/example-note-cover",
      "likedCount": 340
    }
  ],
  "scrapedAt": "2025-01-15T12:05:00.000Z"
}
```

The default dataset contains only successfully parsed public profile records.

Open the run summary in the run key-value store for requested, valid, saved, and failed counts.

### Recent public note context

Recent notes are context attached to a creator snapshot, not a promise to retrieve every post.

A note card can include a title, source type, timestamp, cover, and visible like count.

A note ID and URL appear only when the public page exposes an ID.

Use note context to review current themes before deeper note-level research.

Disable it when you need only creator identity and audience metrics.

Nested notes have no separate charge event.

### Monitoring creator profiles

Create an Apify Task with the same set of profile IDs.

Schedule it daily, weekly, or at the cadence appropriate for your research.

Store each dataset with its `scrapedAt` timestamp.

Compare follower, following, interaction, biography, tag, and recent-note values downstream.

The Actor produces snapshots; it does not send change alerts by itself.

Use a webhook, Make, Zapier, or your own pipeline to calculate changes and notify a team.

### How much does it cost to extract Xiaohongshu creator profiles?

Pricing uses one small `start` event and one `item` event per successfully saved profile.

The `item` event is the primary value event and receives platform volume-tier discounts.

At the BRONZE tier, the price is **$0.003992 per saved profile** plus a **$0.005 run start**.

That makes a one-profile run about $0.0090, 10 saved profiles about $0.0449, and 100 saved profiles about $0.4042 at BRONZE pricing.

The FREE, SILVER, GOLD, PLATINUM, and DIAMOND tiers have their own event prices in the Actor pricing panel.

PLATINUM and DIAMOND mirror GOLD under Apify's standard enterprise tier normalization.

Invalid, unavailable, duplicate, or challenged profiles do not create an `item` charge.

Always check the current pricing panel before a large production run.

### Export and integration workflows

Download the default dataset as JSON for an application pipeline.

Export CSV or Excel for influencer review and campaign planning.

Send new dataset items to Google Sheets through an Apify integration.

Use a dataset webhook to trigger a CRM or warehouse load.

Join rows on `userId` rather than nickname because display names can change.

Keep `scrapedAt` when building historical comparisons.

Use the canonical `profileUrl` as a human-review link.

### Run with the JavaScript API client

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rednote-xiaohongshu-profile-scraper').call({
  userIds: ['630dcb22000000001200cd11'],
  maxProfiles: 1,
  includeRecentNotes: true,
  maxRecentNotesPerProfile: 5
});

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

Store the token in an environment variable rather than source code.

### Run with the Python API client

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/rednote-xiaohongshu-profile-scraper").call(run_input={
    "userIds": ["630dcb22000000001200cd11"],
    "maxProfiles": 1,
    "includeRecentNotes": False,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Replace the sample ID with a public creator you are permitted to research.

### Run with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~rednote-xiaohongshu-profile-scraper/runs?token=$APIFY_TOKEN" \
  -H "content-type: application/json" \
  -d '{
    "profileUrls": [{"url": "https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11"}],
    "maxProfiles": 1,
    "includeRecentNotes": true,
    "maxRecentNotesPerProfile": 3
  }'
```

The run response includes the default dataset and key-value store IDs.

### Use with MCP and AI agents

Add the Apify MCP server in Claude Code:

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

#### Claude Desktop

Add this JSON to the Claude Desktop MCP configuration:

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

#### Cursor

Add the same `mcpServers.apify.url` value in **Cursor Settings → MCP**.

#### VS Code

Add the same HTTP MCP server URL to your VS Code MCP configuration and enable the Actor-specific tool.

Example prompt:

> Extract this public Xiaohongshu creator profile and summarize its audience signals and three recent note topics.

Another useful prompt:

> Enrich these Xiaohongshu user IDs and return nickname, Red ID, location, followers, and tags as a table.

### Reliability and limitations

Xiaohongshu can change its public page structure or return an access challenge.

The Actor retries transient direct failures and can make one materially different datacenter-proxy fallback request.

It fails the run when no useful public profile can be saved.

Partial batches succeed when at least one requested public profile is saved; inspect `RUN_SUMMARY` for skipped targets.

Audience counts are public display signals and can be rounded by the source.

A normalized value of 10,000 from `1万+` means at least that displayed threshold, not an exact private analytics value.

Recent note cards are limited to what the public profile response exposes.

Private, login-only, removed, or region-restricted data is outside scope.

The Actor does not search Xiaohongshu by keyword and does not retrieve comments or private analytics.

### Troubleshooting

**The run says no useful public profiles were saved.**

Check that the URL uses `/user/profile/<24-character-id>` and opens publicly without login.

Try the prefilled profile to separate input problems from an upstream access change.

Review the run summary and run log for a concise reason.

**A metric is missing.**

The source did not expose it in the public profile response. Missing values are omitted rather than invented.

**The follower count looks rounded.**

Xiaohongshu can display localized threshold counts such as `1万+`; the Actor converts the visible value to its numeric threshold.

**There are fewer recent notes than requested.**

The setting is a maximum. The public page may expose fewer usable note cards or omit note IDs.

**Should I enable residential proxy?**

No residential route runs automatically. Discovery testing found the default direct/datacenter path more useful for this workflow.

### Legal and responsible use

Collect only public data you have a lawful reason to process.

Follow Xiaohongshu terms, applicable privacy law, and your organization's data policies.

Do not use profile data to make sensitive inferences about individuals.

Do not scrape private accounts or attempt to bypass login-only access.

Respect creator rights when storing, combining, or contacting people from exported data.

Set retention limits and remove records you no longer need.

Secure API tokens, datasets, exports, and downstream destinations.

This tool provides technical extraction and is not legal advice.

### Related Automation Lab Actors

Use [RedNote Note Detail Scraper](https://apify.com/automation-lab/rednote-note-detail-scraper) when your workflow starts from individual public note URLs and needs note-level detail.

Use [Weibo Posts and Profiles Scraper](https://apify.com/automation-lab/weibo-posts-profiles-scraper) for a related Chinese social intelligence workflow on Weibo.

Use [Cross-platform Influencer Discovery](https://apify.com/automation-lab/cross-platform-influencer-discovery) when you need keyword-led creator discovery across its supported sources rather than Xiaohongshu profile enrichment.

This Actor remains intentionally focused on supplied Xiaohongshu profile URLs and IDs.

### FAQ

**Does the Actor require a Xiaohongshu login?**

No. It reads only public anonymous profile responses.

**Can it accept both RedNote and Xiaohongshu links?**

It accepts public links on `xiaohongshu.com`, which is the supported canonical source for RedNote/Xiaohongshu profiles.

**Does it retrieve every note by a creator?**

No. It includes only bounded recent note-card context exposed on the public profile page.

**Are duplicate IDs charged twice?**

No. IDs are normalized and deduplicated before fetching.

**Can I run it on a schedule?**

Yes. Save the input as an Apify Task and add a schedule, then compare snapshots downstream.

**What happens when one profile fails in a batch?**

Other valid profiles continue. The failed target appears in the run summary and creates no profile item charge.

**What is the maximum batch size?**

One run accepts up to 500 distinct valid profile targets.

**Can I use the results in a spreadsheet?**

Yes. Export the dataset as CSV or Excel, or connect it directly to Google Sheets.

# Actor input Schema

## `profileUrls` (type: `array`):

Public URLs in the form https://www.xiaohongshu.com/user/profile/<user-id>.

## `userIds` (type: `array`):

Xiaohongshu creator IDs containing exactly 24 hexadecimal characters. Use this when your CRM or spreadsheet already stores creator IDs.

## `maxProfiles` (type: `integer`):

Maximum number of distinct valid creators to process in this run.

## `includeRecentNotes` (type: `boolean`):

Attach recent public note cards exposed by the profile page, including titles, timestamps, covers, and visible like counts when available.

## `maxRecentNotesPerProfile` (type: `integer`):

Maximum public note cards nested in each creator record. Set to 0 for profile-only output.

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

Optional proxy settings. The default direct route uses one SHADER datacenter fallback only when the public page is blocked or transiently unavailable.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11"
    }
  ],
  "maxProfiles": 25,
  "includeRecentNotes": true,
  "maxRecentNotesPerProfile": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing normalized public Xiaohongshu creator profiles.

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

Key-value store entry with processing counts and failed-target reasons.

# 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 = {
    "profileUrls": [
        {
            "url": "https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rednote-xiaohongshu-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 = { "profileUrls": [{ "url": "https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rednote-xiaohongshu-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 '{
  "profileUrls": [
    {
      "url": "https://www.xiaohongshu.com/user/profile/630dcb22000000001200cd11"
    }
  ]
}' |
apify call automation-lab/rednote-xiaohongshu-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/rednote-xiaohongshu-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/WTxM0jhEyquCFbmf4/builds/P9VLeG7Kdni14Jjxr/openapi.json