# RedNote (Xiaohongshu) Search Scraper - 500 Notes/30s (`zen-studio/rednote-search-scraper`) Actor

Extract Xiaohongshu (RedNote / 小红书) search results by keyword. Get author profile, engagement counts (likes, comments, collects), image galleries, and playable video stream URLs — 24 fields per note. No headless browser, no captcha. 500 notes in 30s. Filter by note type. JSON/CSV/Excel export.

- **URL**: https://apify.com/zen-studio/rednote-search-scraper.md
- **Developed by:** [Zen Studio](https://apify.com/zen-studio) (community)
- **Categories:** Social media, Videos, Automation
- **Stats:** 11 total users, 5 monthly users, 66.4% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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 (小红书) Search Scraper — Fast Keyword Search, Filters & Full Note Metadata (2026)

<blockquote style="border-left:4px solid #FF2442;background:#FFF5F5;padding:12px 16px">
<span style="font-size:16px;font-weight:700;color:#1C1917">Search RedNote (小红书 / Xiaohongshu) by keyword — full note content, author profile, engagement counts, image gallery, and playable video stream URLs in clean structured JSON</span> <span style="font-size:15px;color:#57534E"> — pick between relevance / most-popular / newest sorts, filter by note type and recency.</span>
</blockquote>

![rednote search scraper hero](https://iili.io/Bmnlu3B.png)

> ⚡ **Built for speed.** No headless browser, no per-page page-load wait, no captcha-solving overhead. **500 notes typically arrive in under 30 seconds**; 1,000 notes in under a minute. Most other Xiaohongshu scrapers drive a headless Chromium instance — this one doesn't.

#### Copy to your AI assistant

````

zen-studio/rednote-search-scraper on Apify. Scrapes Xiaohongshu (RedNote / 小红书) search results by keyword. One row per note with author profile, engagement counts, image gallery, and playable video stream URLs. Call ApifyClient("TOKEN").actor("zen-studio/rednote-search-scraper").call(run\_input={...}), then client.dataset(run\["defaultDatasetId"]).list\_items().items. Requires keywords (string\[]); each keyword runs independently with its own maxResults budget. Full spec: GET https://api.apify.com/v2/acts/zen-studio~rednote-search-scraper/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Token: https://console.apify.com/account/integrations

````

### How to Search RedNote by Keyword

#### Basic — one keyword, default 100 results

```json
{
  "keywords": ["美食推荐"],
  "maxResults": 100
}
````

#### Multi-keyword with sort and type filter

```json
{
  "keywords": ["护肤", "skincare routine"],
  "maxResults": 200,
  "sortType": "popularity_descending",
  "noteType": "video"
}
```

#### Newest-first with recency filter — trend monitoring

```json
{
  "keywords": ["春季穿搭", "春天穿搭"],
  "maxResults": 300,
  "sortType": "time_descending",
  "timeFilter": "1w",
  "topUpFromOtherSorts": false
}
```

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | string\[] | *required* | Search terms. Chinese, English, hashtags, brand names, and emoji all work. Each keyword is searched independently with its own `maxResults` budget. |
| `maxResults` | integer | `100` | How many unique notes to collect per keyword (1–1000). Cost scales linearly with results collected. Narrow or niche keywords may yield fewer than the cap. |
| `sortType` | string | `general` | `general` (Most relevant) / `popularity_descending` (Most popular) / `time_descending` (Newest first). Controls how the platform ranks results for your search. |
| `topUpFromOtherSorts` | boolean | `true` | When the primary sort exhausts results before reaching the cap, automatically pull additional unique notes from the other two sort modes. Recommended ON — you get more for the same per-result price. |
| `noteType` | string | `all` | `all` / `video` / `image` / `live`. Restrict results to a single note format. |
| `timeFilter` | string | `all` | `all` / `1d` (Past 24 hours) / `1w` (Past week) / `6mo` (Past 6 months). Restrict to notes published in a recent window. |

#### Accepted keyword formats

Any term the Xiaohongshu search box accepts:

| Format | Example |
|---|---|
| Chinese word or phrase | `美食推荐`, `护肤心得`, `家常菜` |
| English word | `skincare`, `minimalist`, `coffee` |
| Brand or person name | `iPhone`, `lululemon`, `张大奕` |
| Hashtag | `#美食`, `#穿搭` |
| Emoji | `🍜`, `✨` |

Each keyword is searched independently, then results are deduplicated across sort modes so you never pay twice for the same note. A single keyword typically yields 100–300 unique notes before the platform's catalogue for that query is exhausted — use multiple related keywords for broader coverage.

### Pricing — Pay Per Event (PPE)

**$5.99 per 1,000 results.** Each note written to the dataset counts as one result. No charge for empty keywords, retries, or pagination overhead.

| Event | Per note | Per 1,000 |
|-------|----------|-----------|
| `search-result` (one dataset row) | $0.00599 | $5.99 |

#### Free tier

**5 lifetime runs**, each capped at approximately 20 results from the first keyword. No credit card required. Sufficient for evaluating the output shape and content quality before purchasing.

### Advanced Usage

#### Trend monitoring — newest notes on a rising topic

```json
{
  "keywords": ["防晒霜推荐 2026", "防晒测评"],
  "maxResults": 200,
  "sortType": "time_descending",
  "timeFilter": "1d"
}
```

Schedule this daily to track how quickly a topic gains traction. The `timestamp` field gives exact publish time; `engagement.liked_count` and `engagement.collected_count` reflect current totals.

#### Brand or competitor monitoring

```json
{
  "keywords": ["lululemon", "始祖鸟", "北面"],
  "maxResults": 100,
  "sortType": "popularity_descending",
  "timeFilter": "1w"
}
```

The `keyword` field on each row identifies which brand surfaced the note. Cross-keyword deduplication is automatic.

#### Influencer discovery by niche

```json
{
  "keywords": ["极简护肤", "敏感肌护肤"],
  "maxResults": 500,
  "sortType": "popularity_descending",
  "noteType": "video"
}
```

Sort by `engagement.liked_count` or `engagement.collected_count` after the run to surface the most influential creators for your niche.

#### Maximizing yield on a narrow keyword

```json
{
  "keywords": ["手作皮具教程"],
  "maxResults": 1000,
  "topUpFromOtherSorts": true
}
```

`topUpFromOtherSorts: true` (the default) automatically pulls unique notes from all three sort modes when the primary sort is exhausted. For niche topics this can meaningfully increase the total yield with no extra configuration.

### FAQ

**How many results can I expect per keyword?**
Typically 100–400 unique notes before the platform's index for that query is exhausted, regardless of how high `maxResults` is set. For broader coverage, add multiple related keywords — cross-keyword deduplication is automatic.

**What does `topUpFromOtherSorts` do exactly?**
When the primary sort mode runs out of results before reaching your `maxResults` cap, the actor automatically continues fetching from the other two sort modes (e.g., if you chose Most relevant, it will also pull from Most popular and Newest first). Results are deduplicated by note ID across all passes. Useful for maximizing yield per keyword at no extra per-result cost.

**Do the filters combine?**
Yes. `sortType`, `noteType`, and `timeFilter` all apply together. For example, `sortType=popularity_descending` + `noteType=video` + `timeFilter=1w` returns the most-liked video notes from the past 7 days. Narrow combinations may reduce the result count.

**How fresh is the data?**
Live — fetched on demand at run time. No cached or stale records.

**Are the media URLs permanent?**
The note `url` (e.g., `https://www.xiaohongshu.com/discovery/item/<id>?xsec_token=…`) is the stable reference. Image and video CDN URLs (`images[].url`, `video.url_720p`, etc.) are time-limited and typically expire within hours to a few days. Download media immediately after a run if you need to store it long-term.

**What note types does this cover?**
All four types the Xiaohongshu search surface returns: video notes, image/text notes (called "normal"), and live notes. Filter with the `noteType` input to restrict to one type. The `type` field on each output row tells you which category a note belongs to.

**Can I search by hashtag specifically?**
Yes — pass `"#美食"` as a keyword. The search behaviour and row shape are identical to free-text search.

**Can I scrape a creator's profile, their follower list, or individual note comments?**
Not in this actor. This actor covers keyword search results only.

**What is the `sortSource` field?**
It records which sort pass produced the row: `general` (Most relevant), `popularity_descending` (Most popular), or `time_descending` (Newest first). Useful when `topUpFromOtherSorts` is on and you want to know how each note was surfaced.

**What's the maximum `maxResults` per keyword?**
1,000. In practice, the platform's index for a given query typically saturates before that ceiling; `topUpFromOtherSorts` helps you get closer to it.

### Use Cases

- **Content discovery** — find the highest-engagement notes in any niche to understand what resonates with Xiaohongshu's audience.
- **Trend monitoring** — track newly published notes on rising topics daily or hourly using `time_descending` + `timeFilter`.
- **Influencer research** — identify creators publishing in your category ranked by likes and collects.
- **Brand monitoring** — watch what users post about your brand or competitors across multiple keywords in one run.
- **Competitive analysis** — compare content volume and engagement across competing brands or product lines.
- **Market research** — gauge category interest, note frequency, and audience sentiment on Xiaohongshu before entering a market.

### Support

- **Bugs**: Issues tab
- **Feature requests**: Issues tab

### Legal Compliance

Extracts publicly available search results from Xiaohongshu (RedNote / 小红书). Users must comply with Xiaohongshu's terms of service and applicable data protection regulations (GDPR, CCPA, PIPL).

***

*RedNote (小红书 / Xiaohongshu) search results — full note content, author profile, engagement counts, image gallery, and video stream URLs — one row per match, in clean JSON.*

# Actor input Schema

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

Add one or more search terms.<br><br>• Chinese works: <code>美食推荐</code>, <code>咖啡</code>, <code>穿搭</code><br>• English works too: <code>lululemon</code>, <code>iphone</code>, <code>tokyo</code><br><br>Each keyword runs independently with its own <b>Max results</b> budget.

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

How many unique notes to collect for <b>each keyword</b>. Every result counts toward your bill.<br><br>Narrow keywords (e.g., <code>lululemon align pants size 6</code>) may yield fewer than the cap because the source has a finite catalogue per query.

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

How the source ranks results.<br><br>• <b>Most relevant</b> — curated relevance ranker (default; balanced for most queries)<br>• <b>Most popular</b> — by engagement (likes + comments); surfaces viral hits<br>• <b>Newest first</b> — by publish time; for trend monitoring

## `topUpFromOtherSorts` (type: `boolean`):

Run your chosen <b>Sort by</b> first. If that sort runs out of unique notes before hitting your <b>Max results per keyword</b> target, also fetch from the other two sort modes and merge them — duplicates removed automatically.<br><br><b>Recommended ON</b> (default). Same per-result price, but you typically get <b>2–3× more unique notes</b> for broad keywords like <code>美食</code> or <code>lululemon</code>.<br><br>Turn OFF if you only want notes from your chosen sort order (strict ranking).

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

Restrict to a single note format.<br><br>• <b>All types</b> — image + video + live (default)<br>• <b>Video notes</b> — only entries with playable video<br>• <b>Image notes</b> — only photo galleries<br>• <b>Live notes</b> — only livestream replays (rare)

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

Restrict to notes published in a recent window. Use for trend monitoring or to avoid stale content.

## Actor input object example

```json
{
  "keywords": [
    "美食推荐"
  ],
  "maxResults": 100,
  "sortType": "general",
  "topUpFromOtherSorts": true,
  "noteType": "all",
  "timeFilter": "all"
}
```

# Actor output Schema

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

Dataset of notes — one row per Xiaohongshu search result.

# 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": [
        "美食推荐"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zen-studio/rednote-search-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": ["美食推荐"] }

# Run the Actor and wait for it to finish
run = client.actor("zen-studio/rednote-search-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": [
    "美食推荐"
  ]
}' |
apify call zen-studio/rednote-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote (Xiaohongshu) Search Scraper - 500 Notes/30s",
        "description": "Extract Xiaohongshu (RedNote / 小红书) search results by keyword. Get author profile, engagement counts (likes, comments, collects), image galleries, and playable video stream URLs — 24 fields per note. No headless browser, no captcha. 500 notes in 30s. Filter by note type. JSON/CSV/Excel export.",
        "version": "0.0",
        "x-build-id": "sVW7cWielYQ7ktQoj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zen-studio~rednote-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zen-studio-rednote-search-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/zen-studio~rednote-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zen-studio-rednote-search-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/zen-studio~rednote-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zen-studio-rednote-search-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔍 Search keywords",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add one or more search terms.<br><br>• Chinese works: <code>美食推荐</code>, <code>咖啡</code>, <code>穿搭</code><br>• English works too: <code>lululemon</code>, <code>iphone</code>, <code>tokyo</code><br><br>Each keyword runs independently with its own <b>Max results</b> budget.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "📊 Max results per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many unique notes to collect for <b>each keyword</b>. Every result counts toward your bill.<br><br>Narrow keywords (e.g., <code>lululemon align pants size 6</code>) may yield fewer than the cap because the source has a finite catalogue per query.",
                        "default": 100
                    },
                    "sortType": {
                        "title": "Sort by",
                        "enum": [
                            "general",
                            "popularity_descending",
                            "time_descending"
                        ],
                        "type": "string",
                        "description": "How the source ranks results.<br><br>• <b>Most relevant</b> — curated relevance ranker (default; balanced for most queries)<br>• <b>Most popular</b> — by engagement (likes + comments); surfaces viral hits<br>• <b>Newest first</b> — by publish time; for trend monitoring",
                        "default": "general"
                    },
                    "topUpFromOtherSorts": {
                        "title": "Combine all sort modes for more unique notes",
                        "type": "boolean",
                        "description": "Run your chosen <b>Sort by</b> first. If that sort runs out of unique notes before hitting your <b>Max results per keyword</b> target, also fetch from the other two sort modes and merge them — duplicates removed automatically.<br><br><b>Recommended ON</b> (default). Same per-result price, but you typically get <b>2&ndash;3&times; more unique notes</b> for broad keywords like <code>美食</code> or <code>lululemon</code>.<br><br>Turn OFF if you only want notes from your chosen sort order (strict ranking).",
                        "default": true
                    },
                    "noteType": {
                        "title": "Note type",
                        "enum": [
                            "all",
                            "video",
                            "image",
                            "live"
                        ],
                        "type": "string",
                        "description": "Restrict to a single note format.<br><br>• <b>All types</b> — image + video + live (default)<br>• <b>Video notes</b> — only entries with playable video<br>• <b>Image notes</b> — only photo galleries<br>• <b>Live notes</b> — only livestream replays (rare)",
                        "default": "all"
                    },
                    "timeFilter": {
                        "title": "Time window",
                        "enum": [
                            "all",
                            "1d",
                            "1w",
                            "6mo"
                        ],
                        "type": "string",
                        "description": "Restrict to notes published in a recent window. Use for trend monitoring or to avoid stale content.",
                        "default": "all"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
