# Xiaohongshu (RedNote) Pro Scraper (`habit.zhou/xiaohongshu-pro-scraper`) Actor

Five-mode Xiaohongshu / RedNote scraper: keyword search, note details, user profile, topic feed, trending. Returns title, body, likes, collects, comments, hashtags, images, video, location, time. No cookies. For trend tracking, AI training data, market research, KOL discovery.

- **URL**: https://apify.com/habit.zhou/xiaohongshu-pro-scraper.md
- **Developed by:** [Seller Aim](https://apify.com/habit.zhou) (community)
- **Categories:** AI, Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.99 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Xiaohongshu (RedNote) Pro Scraper

Full-featured **Xiaohongshu / 小红书 / RedNote** scraper. Five modes, one Actor, clean structured JSON. No login, no cookies, no broken-token surprises.

Built for serious workloads — market research teams pulling daily competitive intelligence, AI training pipelines harvesting Chinese-language UGC, KOL discovery tools, brand-watch dashboards.

### What does this Actor do?

Pick a mode, give it inputs, get a dataset:

- **Keyword search** — search Xiaohongshu by keyword with full sort and filter options (newest, most liked, video-only, last 24h, etc.)
- **Note details** — paste a note URL, get the full body, all images, hashtags, engagement counts, location, and optional comments.
- **User profile + posts** — fetch a creator's profile (followers, IP location, bio) plus their recent posts in one run.
- **Topic / hashtag feed** — pull every recent note tagged with a topic.
- **Public trending feed** — the anonymous "Hot Notes" homepage strip, no Xiaohongshu account needed.

Each note returns a flat, schema-validated JSON row that's downloadable as JSON, CSV, Excel, HTML, or XML — and queryable via the Apify REST API for pipeline integration.

### Why use Xiaohongshu Pro Scraper?

- **No cookies, no breakage.** Other Xiaohongshu actors in the store rely on the user's logged-in cookie which expires every few days. Customers end up with a stream of 401s and 1.5★ reviews. We use a maintained mobile-app endpoint that stays stable.
- **Five modes in one Actor.** Search, note detail, user, topic, trending — pick a mode per run; no juggling separate Actors.
- **Full-field output.** Title, body text, author, likes, collects, comment count, hashtags, image gallery, video URL, publish time, geo / IP location — all in one row.
- **AI training-ready.** Chinese-language UGC, clean JSON, deduplicable by `noteId`. Drop straight into a vector DB, an LLM fine-tune set, or a trend classifier.
- **Marketing dashboards.** Schedule keyword runs hourly and build a real-time pulse of any brand, product, or hashtag.

### How to use

1. Open the Actor and click **Try for free**.
2. In the Input tab, pick a **Scrape mode** (search is the default).
3. Fill the inputs for your mode:
   - **search**: keywords, optional sort/filter
   - **notes**: full note URLs
   - **user**: user IDs
   - **topic**: topic names (without `#`)
   - **trending**: nothing required
4. Set **Max items per input** (default 30).
5. Click **Save & Start**. Results stream into the dataset live.
6. Download or stream the dataset; schedule the run under the **Schedules** tab.

### Input

| Field | Type | Used in mode | Description |
|---|---|---|---|
| `mode` | string | all | One of `search`, `notes`, `user`, `topic`, `trending`. |
| `keywords` | array<string> | search | Keywords to search. |
| `noteUrls` | array<URL> | notes | Note URLs to fetch details for. |
| `userIds` | array<string> | user | User IDs to fetch profiles and posts for. |
| `topicNames` | array<string> | topic | Topic / hashtag names (without `#`). |
| `maxItemsPerInput` | integer (1–500) | all | Cap per input. Default 30. |
| `sortType` | enum | search | `general` / `time_descending` / `popularity_descending` / `comment_descending` / `collect_descending`. |
| `noteType` | enum | search | `不限` / `视频笔记` / `普通笔记` / `直播笔记`. |
| `timeFilter` | enum | search | `不限` / `一天内` / `一周内` / `半年内`. |
| `fetchComments` | boolean | notes, search | Also fetch up to 20 top comments per note. Extra cost. |
| `proxyConfiguration` | object | trending only | Only used for trending fallback. |

JSON example — keyword search:

```json
{
    "mode": "search",
    "keywords": ["AI编程", "护肤"],
    "maxItemsPerInput": 100,
    "sortType": "popularity_descending",
    "timeFilter": "一周内",
    "fetchComments": false
}
````

### Output

```json
{
    "noteId": "69fba039000000003803426d",
    "title": "Claude Code 零基础终极教程！",
    "bodyText": "这是你能看到的最完整的Claude Code 零基础系统教程。 🔹 从安装到接入第三方模型 🔹 讲透 Hooks、S…",
    "author": "木子不写代码",
    "authorId": "5e2a3c1d000000000100abc7",
    "likes": 117895,
    "collects": 172097,
    "commentsCount": 4521,
    "isVideo": true,
    "imageUrls": [
        "https://sns-webpic-qc.xhscdn.com/.../1.jpg"
    ],
    "videoUrl": "https://sns-video-bd.xhscdn.com/.../master.mp4",
    "hashtags": ["#ClaudeCode", "#AI编程", "#提示词"],
    "publishedAt": "2026-04-13T09:42:00.000Z",
    "location": "上海",
    "comments": [
        { "author": "用户A", "text": "太实用！", "likes": 42 }
    ],
    "noteUrl": "https://www.xiaohongshu.com/explore/69fba039000000003803426d",
    "keyword": "AI编程",
    "scrapedAt": "2026-05-22T09:26:33.733Z"
}
```

#### Output fields

| Field | Description |
|---|---|
| `noteId` | Xiaohongshu's internal note ID. |
| `title` | Note title. |
| `bodyText` | Full note body text. |
| `author` | Display name of the author. |
| `authorId` | Internal user ID — pair with `mode: "user"` to drill into the author. |
| `likes` | Like count. |
| `collects` | Collect (favourite) count. |
| `commentsCount` | Total comment count. |
| `isVideo` | True if Xiaohongshu marks the note as a video. |
| `imageUrls` | All images in the note. |
| `videoUrl` | Video src for video notes. |
| `hashtags` | Hashtags / topics referenced. |
| `publishedAt` | ISO 8601 publish time. |
| `location` | Author IP location (city / region). |
| `comments` | Up to 20 top comments when `fetchComments` is on. |
| `noteUrl` | Public deep link. |
| `keyword` | Search keyword that surfaced this note (search mode only). |
| `topic` | Topic name (topic mode only). |
| `userId` | Author ID (user mode only). |
| `scrapedAt` | ISO 8601 timestamp of scrape. |

### Pricing

**$3.99 per 1,000 results.** Each note returned counts as one result. Detail mode with `fetchComments=true` returns richer rows but is billed at the same rate.

#### Cost estimates

| Goal | Items / run | Mode | Est. cost / run |
|---|---|---|---|
| Quick scan of one keyword | 50 | search | ~$0.20 |
| Hashtag round-up | 500 | search | ~$2.00 |
| KOL deep dive | 200 + comments | notes | ~$0.80 |
| Daily brand monitoring | 1,000 | search | ~$4.00 / day |

Apify also charges a small compute fee (typically $0.01-0.05 per minute of run time).

### Tips

- **Schedule, don't poll.** Xiaohongshu rotates trending content every few hours; scheduling daily / 6-hourly delivers the right cadence vs cost.
- **Deduplicate by `noteId`.** Sequential runs overlap; merge and dedupe on the `noteId` field.
- **Pair user + notes modes.** Use `mode: "user"` to find prolific authors, then drill into each top note with `mode: "notes"`.
- **Pair `popularity_descending` with `timeFilter: "一周内"`** to surface this week's breakout posts.
- **Don't enable `fetchComments` unless you need them.** Each comment-bearing note takes an extra request and doubles per-row time.

### FAQ

**Q: Why is this Actor different from the other Xiaohongshu scrapers on the Store?**
A: Most existing actors depend on the customer providing a logged-in Xiaohongshu cookie that expires every few days. We don't. We've engineered around the public mobile-app surface so the Actor stays stable across cookie expiries.

**Q: Will this break when Xiaohongshu changes their API?**
A: Possibly. Our team maintains the backend; we patch usually within 24-72 hours of a backend change. Bug reports via the Issues tab.

**Q: Is scraping Xiaohongshu legal?**
A: We pull only publicly-accessible content — what any visitor can see without an account. Your usage is your responsibility; comply with your jurisdiction's law and Xiaohongshu's Terms of Service. Do not scrape private profiles or use the data to identify individuals.

**Q: Can I get my data via API?**
A: Yes. Every Apify run exposes a stable [REST API](https://docs.apify.com/api/v2) for inputs, datasets, and run status. Plug into n8n, Make, Zapier, or your own pipeline.

**Q: Is there a free tier?**
A: The Apify platform gives every new account $5 in free credit — enough for ~1,000 results to evaluate the Actor before committing. The trending mode in this Actor is also free of per-result charges (it runs on Apify residential proxies; you pay only compute).

**Q: How fast are runs?**
A: Search mode: ~5 seconds per page (≈20 notes). User mode: ~3 seconds per page. Note-detail mode: 1-2 seconds per note. Topic mode: ~4 seconds per page.

**Q: I need a richer integration or higher-volume contract.**
A: Reach out via Apify chat. Custom endpoints, dedicated proxies, and SLAs available on request.

# Actor input Schema

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

What kind of data to pull from Xiaohongshu / RedNote.

## `keywords` (type: `array`):

Keywords to search for in Xiaohongshu. Used when mode is 'search'.

## `noteUrls` (type: `array`):

Xiaohongshu note URLs to fetch full details for. Used when mode is 'notes'. Format: https://www.xiaohongshu.com/explore/<noteId>

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

Xiaohongshu user IDs to fetch profiles + recent posts for. Used when mode is 'user'. Find a user ID in the profile URL (/user/profile/<userId>).

## `topicNames` (type: `array`):

Topic names (without leading #) to fetch the feed for. Used when mode is 'topic'.

## `maxItemsPerInput` (type: `integer`):

Cap per keyword / URL / user / topic. Each item returned is one billed result.

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

Sort order for keyword search.

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

Filter by note type.

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

Filter by recency.

## `fetchComments` (type: `boolean`):

When on, fetches up to 20 top comments per note. Significantly increases run time and is billed per comment-bearing note.

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

Only used in the 'trending' fallback mode. The other modes do not need proxies.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "AI"
  ],
  "noteUrls": [],
  "userIds": [],
  "topicNames": [],
  "maxItemsPerInput": 30,
  "sortType": "general",
  "noteType": "不限",
  "timeFilter": "不限",
  "fetchComments": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "AI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("habit.zhou/xiaohongshu-pro-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 = { "keywords": ["AI"] }

# Run the Actor and wait for it to finish
run = client.actor("habit.zhou/xiaohongshu-pro-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 '{
  "keywords": [
    "AI"
  ]
}' |
apify call habit.zhou/xiaohongshu-pro-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xiaohongshu (RedNote) Pro Scraper",
        "description": "Five-mode Xiaohongshu / RedNote scraper: keyword search, note details, user profile, topic feed, trending. Returns title, body, likes, collects, comments, hashtags, images, video, location, time. No cookies. For trend tracking, AI training data, market research, KOL discovery.",
        "version": "0.2",
        "x-build-id": "x7UWVsLrZ1agwss7q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/habit.zhou~xiaohongshu-pro-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-habit.zhou-xiaohongshu-pro-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/habit.zhou~xiaohongshu-pro-scraper/runs": {
            "post": {
                "operationId": "runs-sync-habit.zhou-xiaohongshu-pro-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/habit.zhou~xiaohongshu-pro-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-habit.zhou-xiaohongshu-pro-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "search",
                            "notes",
                            "user",
                            "topic",
                            "trending"
                        ],
                        "type": "string",
                        "description": "What kind of data to pull from Xiaohongshu / RedNote.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keywords to search for in Xiaohongshu. Used when mode is 'search'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "noteUrls": {
                        "title": "Note URLs",
                        "type": "array",
                        "description": "Xiaohongshu note URLs to fetch full details for. Used when mode is 'notes'. Format: https://www.xiaohongshu.com/explore/<noteId>",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "userIds": {
                        "title": "User IDs",
                        "type": "array",
                        "description": "Xiaohongshu user IDs to fetch profiles + recent posts for. Used when mode is 'user'. Find a user ID in the profile URL (/user/profile/<userId>).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "topicNames": {
                        "title": "Topic / hashtag names",
                        "type": "array",
                        "description": "Topic names (without leading #) to fetch the feed for. Used when mode is 'topic'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerInput": {
                        "title": "Max items per input",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap per keyword / URL / user / topic. Each item returned is one billed result.",
                        "default": 30
                    },
                    "sortType": {
                        "title": "Sort (search mode)",
                        "enum": [
                            "general",
                            "time_descending",
                            "popularity_descending",
                            "comment_descending",
                            "collect_descending"
                        ],
                        "type": "string",
                        "description": "Sort order for keyword search.",
                        "default": "general"
                    },
                    "noteType": {
                        "title": "Note type (search mode)",
                        "enum": [
                            "不限",
                            "视频笔记",
                            "普通笔记",
                            "直播笔记"
                        ],
                        "type": "string",
                        "description": "Filter by note type.",
                        "default": "不限"
                    },
                    "timeFilter": {
                        "title": "Published within (search mode)",
                        "enum": [
                            "不限",
                            "一天内",
                            "一周内",
                            "半年内"
                        ],
                        "type": "string",
                        "description": "Filter by recency.",
                        "default": "不限"
                    },
                    "fetchComments": {
                        "title": "Also fetch top comments per note",
                        "type": "boolean",
                        "description": "When on, fetches up to 20 top comments per note. Significantly increases run time and is billed per comment-bearing note.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (trending mode only)",
                        "type": "object",
                        "description": "Only used in the 'trending' fallback mode. The other modes do not need proxies.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```