# RedNote (Xiaohongshu) Scraper (`nexgendata/rednote-scraper`) Actor

Scrape RedNote / Xiaohongshu (小红书) posts across four modes: trending, user\_posts, hashtag, keyword\_search. Extracts post id, author, title, body, images, hashtags, likes/comments/shares, posted-at timestamp.

- **URL**: https://apify.com/nexgendata/rednote-scraper.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Social media
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 rednote posts

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

## RedNote (Xiaohongshu) Scraper — Trending, Users, Hashtags & Search

**The canonical RedNote / Xiaohongshu (小红书) scraper for Apify.** Pull trending notes, search by keyword, scrape hashtag/topic pages, or extract a specific user's posts — with structured JSON output ready to drop into a dashboard, CRM or quant model.

RedNote (小红书 / Little Red Book) is China's dominant lifestyle super-app — "Instagram + Pinterest + Yelp + Amazon reviews" rolled into one. **300M+ MAU, ~70% female, average age 25**, with an unusually high concentration in tier-1 / tier-2 mainland cities (Shanghai, Beijing, Shenzhen, Guangzhou, Chengdu). After the 2025 TikTok ban scare, an additional ~700K self-described "TikTok refugees" joined RedNote in 72 hours, accelerating its international footprint.

Crucially, **every viral RedNote note is, in effect, a product review or a buying guide.** Trending RedNote content is the closest publicly observable signal to Chinese consumer demand — earlier and cleaner than Tmall / JD sales rankings, and orders of magnitude more granular than Nielsen-style panel data. This actor extracts that signal as clean JSON, on demand, with no manual scrolling and no Mandarin-speaking analyst in Shanghai required.

This actor was the **#1 most-requested scraper on the Apify Ideas page** (45 community upvotes, 2.5× the next-highest request).

---

### What you get per record

Every RedNote post returned by the actor is structured as:

| Field | Type | Description |
|---|---|---|
| `post_id` | string | RedNote note id (the `/explore/{id}` hex token) |
| `author` | string | Note author's display name |
| `author_id` | string | Author's user id (joinable to user_posts mode) |
| `title` | string | Note title |
| `body` | string | Note caption / description text |
| `image_urls` | list | Image URLs attached to the note (up to 9) |
| `hashtags` | list | Hashtags extracted from title + body |
| `likes_count` | int | Likes (decoded from `12.3万` / `1.2k` shorthand) |
| `comments_count` | int | Comment count |
| `shares_count` | int | Share count |
| `collected_count` | int | Save / collect count |
| `engagement_total` | int | Sum of likes + collected + comments + shares |
| `posted_at` | string | ISO-8601 timestamp when the note was published |
| `url` | string | Canonical `xiaohongshu.com/explore/{id}` deep link |
| `category` | string | `beauty` / `fashion` / `food` / `travel` / `wellness` / `tech` / `finance` / `lifestyle` |
| `mode` | string | `trending` / `keyword_search` / `hashtag` / `user_posts` |
| `query` | string | The input that produced this record (keyword / hashtag / user) |
| `data_source` | string | Provenance (`httpx` vs `playwright`, mode) |
| `as_of_timestamp` | string | UTC ISO-8601 capture time |

If — and only if — every probe strategy is fully blocked by RedNote's anti-bot wall, the actor emits a single `status: "maintenance"` record explaining the situation and listing the sister actors you can fall back on. Your downstream pipeline never crashes. **No charge is applied for maintenance stubs.**

---

### Four scrape modes

Set `mode` to one of the following:

#### `trending`
Pulls the RedNote homepage discovery feed (`/explore`) — the same surface a logged-out RedNote user lands on. Great for "what's hot on RedNote right now" daily monitoring. No other inputs needed.

#### `keyword_search`
Searches RedNote for one or more keywords (`keywords` array). Chinese characters give native-quality hits (e.g. `["口红", "护肤", "穿搭"]`); English fall-backs work too (e.g. `["lipstick", "skincare", "outfit"]`). Use this for brand mention monitoring, competitive product research, or category sweeps.

#### `hashtag`
Pulls notes tagged with one or more hashtags / topics (`hashtags` array). Provide tag text without the leading `#` (e.g. `["秋冬穿搭", "咖啡探店"]`). Falls back to keyword search if the topic page is unavailable. Use this for tracking a specific campaign tag, a trending topic, or a community hashtag.

#### `user_posts`
Pulls recent posts from one or more specific users (`users` array). Accepts full profile URL (`https://www.xiaohongshu.com/user/profile/{id}`), a path (`/user/profile/{id}`), or just the bare user id. Use this for KOL / influencer monitoring, creator-economy research, or pulling a portfolio of brand-owned accounts.

---

### How the actor handles RedNote's anti-bot wall

RedNote is hosted in mainland China and applies aggressive bot detection on datacenter IPs (HTTP 403/461, empty feeds, captcha walls). The actor uses a multi-strategy waterfall:

1. **`httpx` + realistic browser headers** with `zh-CN` locale and a real Chrome User-Agent — extracts `window.__INITIAL_STATE__` when RedNote renders server-side hydration data.
2. **DOM-level fallback parser** — pulls `/explore/{id}` anchors and inferred titles when the hydrated state blob is absent or partial.
3. **Playwright headless Chromium with stealth countermeasures** — `navigator.webdriver` patch, `zh-CN` locale, `Asia/Shanghai` timezone, realistic viewport, plugin / languages spoofing. Handles JS-rendered hydration when HTML alone isn't enough.
4. **Maintenance-stub fallback** — graceful single-row response so consumer pipelines don't break (and no charge applied).

All paths run behind Apify's **RESIDENTIAL proxy** pool by default, which is strongly recommended for RedNote.

---

### How buyers actually use this actor

- **Beauty / fashion e-commerce ops** — daily 5-keyword `keyword_search` monitor against the brand portfolio + 3 closest competitors. Plug into Slack via webhook for "your brand just appeared on RedNote trending" alerts.
- **China market-entry consultants** — weekly 200-record `keyword_search` sweep across `美妆` + `健身` + `生活方式` to identify whitespace categories before a client launch.
- **KOL / influencer agencies** — daily `user_posts` pull of the top 50 KOLs in a vertical to track posting cadence, engagement decay and brand-collab disclosures.
- **Hedge fund consumer-discretionary desks** — `trending` + `hashtag` records as a real-time alt-data feed for theses on Estée Lauder, L'Oréal, Anta, Li Ning, Pop Mart.
- **Brand-safety / compliance teams** — flag `is_branded_partnership=true` posts that mention competitors for review.
- **TikTok refugees research** — `hashtag` mode against the migration tags (`#TikTokRefugee`, `#Xiaohongshu`) to size and segment the cross-platform user influx.

---

### How this compares to incumbent China consumer-trend tools

| Capability | RedNote Scraper (NexGenData) | Bloomberg China Consumer Pulse | Nielsen China | Kantar Worldpanel | Hootsuite China |
|---|---|---|---|---|---|
| Per-record API access | Yes (pay-per-event) | Terminal subscription only | Annual contract | Annual contract | Seat-based SaaS |
| Latency | Live (≤2 min) | Daily | Monthly panel | Weekly | Daily-ish |
| Cost to first record | Cents | $24k+/year/seat | $80k+/year minimum | $50k+/year minimum | $9k+/year |
| Four scrape modes (trending / search / hashtag / user) | Yes | No | No | No | Limited |
| Self-serve, no contract | Yes | No | No | No | No |
| Pipeline-friendly JSON | Yes | CSV / terminal | PDF / Tableau | Excel | CSV |

The incumbents are useful for board-level narratives; this actor is what you wire into your daily marketing-ops dashboard.

---

### Pair it with the NexGenData China & Social-Listening fleet

This actor is one slice of NexGenData's purpose-built Chinese-data fleet on Apify. The other essentials:

- **[Weibo Hot Search Tracker](https://apify.com/nexgendata/weibo-hot-search-tracker)** — real-time Weibo trending topics ("China's Twitter").
- **[Bilibili Video Search](https://apify.com/nexgendata/bilibili-video-search)** — China's YouTube / Twitch — video discovery & metadata.
- **[China Trends Tracker](https://apify.com/nexgendata/china-trends-tracker)** — cross-platform trending aggregator across Weibo / Douyin / Baidu / WeChat.
- **[Eastmoney China Stock Screener](https://apify.com/nexgendata/eastmoney-china-stock-screener)** — A-share fundamental / momentum data for joining consumer trends to public-company tickers.
- **[HKEX IPO Tracker](https://apify.com/nexgendata/hkex-ipo-tracker)** — Hong Kong IPO pipeline for cross-border brand listings.
- **[Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server)** — one-call MCP wrapper bundling the Chinese finance fleet for LLM agents.

Build a cross-border consumer-trend pipeline by pairing **RedNote Scraper** (demand signal) with **Eastmoney** (public-company tickers) and **HKEX IPO** (listing pipeline) — daily.

---

### Get 20% off your first 3 months on Apify

If you're new to Apify, use [this referral link](https://www.apify.com/?fpr=2ayu9b) to sign up and get **20% off for 3 months, then 30% ongoing**. Pairs cleanly with any of the China / social-listening actors above.

---

### Input parameters

- `mode` — `trending` (default) / `keyword_search` / `hashtag` / `user_posts`.
- `keywords` — array of Chinese or English search terms (used in `keyword_search` mode).
- `hashtags` — array of hashtags / topic slugs without leading `#` (used in `hashtag` mode).
- `users` — array of full URL / path / bare user id (used in `user_posts` mode).
- `limit` — max records to return (1-500; default 30).
- `proxyConfiguration` — Apify proxy (defaults to RESIDENTIAL — strongly recommended).

---

### Disclaimer

This actor pulls publicly visible RedNote content using the same browser endpoints any logged-out RedNote.com visitor reaches. It does not bypass paywalls, login walls, age gates or private profiles. Buyers are responsible for compliance with RedNote's Terms of Service and applicable Chinese / EU / US data regulations in their jurisdiction.

# Actor input Schema

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

What to scrape. 'trending' pulls the homepage discovery feed (no other inputs needed). 'keyword_search' searches RedNote for the keywords in the 'keywords' field (Chinese or English). 'hashtag' pulls posts under the hashtag/topic pages in 'hashtags'. 'user_posts' pulls recent posts from each user reference in 'users' (accepts full URL, /user/profile/{id}, or bare user id).
## `keywords` (type: `array`):

List of search terms for 'keyword_search' mode. Chinese characters give native-quality hits (e.g. ['口红', '护肤', '穿搭']); English fall-backs work too (e.g. ['lipstick', 'skincare', 'outfit']). Ignored in other modes.
## `hashtags` (type: `array`):

List of RedNote hashtags or topic slugs to pull posts for, in 'hashtag' mode. Provide the tag text without the leading '#' (e.g. ['秋冬穿搭', '咖啡探店']). Falls back to keyword search if the topic page is unavailable. Ignored in other modes.
## `users` (type: `array`):

List of RedNote user references for 'user_posts' mode. Accepts a full profile URL (https://www.xiaohongshu.com/user/profile/{id}), a path (/user/profile/{id}), or just the bare user id. Ignored in other modes.
## `limit` (type: `integer`):

Maximum number of RedNote posts to return per run (across all keywords / hashtags / users). 10-30 is appropriate for daily monitoring; 100+ for one-off research sweeps.
## `proxyConfiguration` (type: `object`):

Apify proxy configuration. RESIDENTIAL is strongly recommended — RedNote is hosted in mainland China and applies anti-bot detection on datacenter IPs (returns 403/461 or empty feeds). Residential CN-egress IPs work best; the actor falls back through httpx → Playwright → maintenance stub.

## Actor input object example

```json
{
  "mode": "trending",
  "keywords": [
    "护肤",
    "口红",
    "穿搭"
  ],
  "hashtags": [
    "秋冬穿搭"
  ],
  "users": [],
  "limit": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# 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 = {
    "mode": "trending",
    "keywords": [
        "护肤",
        "口红",
        "穿搭"
    ],
    "hashtags": [
        "秋冬穿搭"
    ],
    "users": [],
    "limit": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/rednote-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 = {
    "mode": "trending",
    "keywords": [
        "护肤",
        "口红",
        "穿搭",
    ],
    "hashtags": ["秋冬穿搭"],
    "users": [],
    "limit": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/rednote-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 '{
  "mode": "trending",
  "keywords": [
    "护肤",
    "口红",
    "穿搭"
  ],
  "hashtags": [
    "秋冬穿搭"
  ],
  "users": [],
  "limit": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nexgendata/rednote-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote (Xiaohongshu) Scraper",
        "description": "Scrape RedNote / Xiaohongshu (小红书) posts across four modes: trending, user_posts, hashtag, keyword_search. Extracts post id, author, title, body, images, hashtags, likes/comments/shares, posted-at timestamp.",
        "version": "0.0",
        "x-build-id": "gEa7mJeFjvogPcqnP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~rednote-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-rednote-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/nexgendata~rednote-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-rednote-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/nexgendata~rednote-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-rednote-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": "Scrape mode",
                        "enum": [
                            "trending",
                            "keyword_search",
                            "hashtag",
                            "user_posts"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'trending' pulls the homepage discovery feed (no other inputs needed). 'keyword_search' searches RedNote for the keywords in the 'keywords' field (Chinese or English). 'hashtag' pulls posts under the hashtag/topic pages in 'hashtags'. 'user_posts' pulls recent posts from each user reference in 'users' (accepts full URL, /user/profile/{id}, or bare user id).",
                        "default": "trending"
                    },
                    "keywords": {
                        "title": "Keywords (keyword_search mode)",
                        "type": "array",
                        "description": "List of search terms for 'keyword_search' mode. Chinese characters give native-quality hits (e.g. ['口红', '护肤', '穿搭']); English fall-backs work too (e.g. ['lipstick', 'skincare', 'outfit']). Ignored in other modes.",
                        "default": [
                            "护肤",
                            "口红",
                            "穿搭"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "hashtags": {
                        "title": "Hashtags / topics (hashtag mode)",
                        "type": "array",
                        "description": "List of RedNote hashtags or topic slugs to pull posts for, in 'hashtag' mode. Provide the tag text without the leading '#' (e.g. ['秋冬穿搭', '咖啡探店']). Falls back to keyword search if the topic page is unavailable. Ignored in other modes.",
                        "default": [
                            "秋冬穿搭"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "users": {
                        "title": "User references (user_posts mode)",
                        "type": "array",
                        "description": "List of RedNote user references for 'user_posts' mode. Accepts a full profile URL (https://www.xiaohongshu.com/user/profile/{id}), a path (/user/profile/{id}), or just the bare user id. Ignored in other modes.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Max records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of RedNote posts to return per run (across all keywords / hashtags / users). 10-30 is appropriate for daily monitoring; 100+ for one-off research sweeps.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. RESIDENTIAL is strongly recommended — RedNote is hosted in mainland China and applies anti-bot detection on datacenter IPs (returns 403/461 or empty feeds). Residential CN-egress IPs work best; the actor falls back through httpx → Playwright → maintenance stub.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```