# RedNote (Xiaohongshu) Consumer Insights Scraper (`yowling_blade/rednote-consumer-insights`) Actor

Cookie-free Xiaohongshu keyword research with normalized notes, selective comments, and ready-made engagement and creator insights.

- **URL**: https://apify.com/yowling\_blade/rednote-consumer-insights.md
- **Developed by:** [Chenglin Wei](https://apify.com/yowling_blade) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 note 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

## RedNote (Xiaohongshu) Consumer Insights Scraper

Turn RedNote/Xiaohongshu (小红书) keyword searches into a research-ready dataset and an instant engagement summary—without supplying a RedNote cookie, residential proxy, or third-party API account.

The Actor identifies the strongest posts and creators, compares content formats, calculates engagement totals and medians, and can selectively enrich the most valuable notes with comments. Use it for China-market research, brand monitoring, creator discovery, product-demand research, and content benchmarking.

### Why this Actor

- **No customer cookie:** users do not maintain RedNote sessions or signing logic.
- **Analysis-ready output:** noisy tracking, debug, and redundant media fields are removed.
- **Keyword insights:** totals, medians, content mix, top notes, and top creators are computed without an LLM.
- **Optional comments:** enrich only the highest-engagement notes or a bounded set of returned notes.
- **Predictable costs:** every upstream page and every saved result has a documented event price.
- **Hard safety limits:** the Actor stops before another paid API call when the user or owner spending ceiling is reached.

### Quick start

```json
{
  "keywords": ["护肤", "AI"],
  "maxResultsPerKeyword": 40,
  "sortBy": "mostLiked",
  "noteType": "all",
  "publishedWithin": "week",
  "commentMode": "topN",
  "maxNotesWithComments": 5,
  "maxCommentPagesPerNote": 1,
  "commentSort": "mostLiked",
  "includeMediaUrls": true
}
````

Chinese keywords usually return the strongest native results. Each keyword is paginated independently, and duplicate notes are removed within that keyword.

### Input

| Field | Default | Limits | Purpose |
|---|---:|---:|---|
| `keywords` | `["AI"]` | 1–20 | Search terms. Whitespace and case-insensitive duplicates are removed. |
| `maxResultsPerKeyword` | `20` | 1–1,000 | Maximum saved notes for each keyword. |
| `sortBy` | `mostLiked` | enum | `relevance`, `latest`, `mostLiked`, `mostCommented`, or `mostCollected`. |
| `noteType` | `all` | enum | `all`, `image`, `video`, or `live`. |
| `publishedWithin` | `week` | enum | `anytime`, `day`, `week`, or `sixMonths`. |
| `commentMode` | `none` | enum | `none`, `topN`, or `all` up to the configured safety limit. |
| `maxNotesWithComments` | `5` | 1–50 | Global maximum notes to enrich with comments. |
| `maxCommentPagesPerNote` | `1` | 1–10 | Maximum comment pages for each enriched note. |
| `commentSort` | `mostLiked` | enum | `mostLiked` or `latest`. |
| `includeMediaUrls` | `true` | boolean | Include normalized cover, image, and one preferred video URL. |
| `debug` | `false` | boolean | Add sanitized progress logs; never logs credentials or raw payloads. |

### Output

The default dataset contains one homogeneous record per note. Comments, when requested, are nested under the note that owns them.

```json
{
  "keyword": "AI",
  "rank": 1,
  "noteId": "6a48f64e00000000110193ea",
  "noteUrl": "https://www.xiaohongshu.com/explore/6a48f64e00000000110193ea",
  "title": "Example note",
  "description": "Normalized note text",
  "contentType": "video",
  "publishedAt": "2026-07-06T00:00:00.000Z",
  "author": {
    "id": "creator-id",
    "redId": "creator-red-id",
    "nickname": "Example creator",
    "avatarUrl": "https://..."
  },
  "engagement": {
    "likes": 121006,
    "collects": 18370,
    "comments": 537,
    "shares": 3180,
    "weightedScore": 172077
  },
  "media": {
    "coverUrl": "https://...",
    "imageUrls": [],
    "videoUrl": "https://...",
    "videoDurationSeconds": 74
  },
  "comments": [],
  "commentPage": {
    "fetchedPages": 0,
    "fetchedComments": 0,
    "reportedTotal": 537,
    "hasMore": false,
    "partial": false
  },
  "source": {
    "platform": "rednote",
    "provider": "tikhub-via-monid",
    "fetchedAt": "2026-07-09T22:00:00.000Z"
  }
}
```

The weighted score is:

`likes + (2 × collects) + (3 × comments) + (4 × shares)`

The default key-value store record `OUTPUT` contains:

- Run status and dataset item count.
- Per-keyword totals, medians, content types, top notes, and top creators.
- Successful search and comment call counts.
- Actual upstream cost and inspected endpoint prices.
- Actual Apify event counts and effective customer charge total.
- Warnings and partial-result reasons.
- Start, completion, and elapsed timestamps.

### Pricing

This Actor uses Apify pay per event (PPE):

| Event | Price | Trigger |
|---|---:|---|
| `apify-actor-start` | $0.00005 | Apify starts the Actor (one event per GB of memory, minimum one). |
| `apify-default-dataset-item` | $0.00001 | One item is written to the default dataset. |
| `search-page` | $0.02 | A RedNote search page succeeds. |
| `comment-page` | $0.02 | A RedNote comment page succeeds. |
| `note-result` | $0.003 | A normalized note is accepted for output. |
| `comment-result` | $0.003 | A normalized comment is included. |

A normal single-page run returning 20 notes costs about **$0.08025** including the Actor-start and dataset-item events, or about **$4.01 per 1,000 notes**. A 10-comment page adds about **$0.05010** for the page, comment results, and their dataset items; the one-time Actor-start fee applies once per run.

Provider failures are not charged as successful pages or results. If the run reaches your Apify maximum charge, it stops before starting another upstream page and returns the records already produced.

### Partial results

A `partial` status is deliberate and machine-readable. Common reasons include:

- The user-selected maximum charge was reached.
- The owner upstream-cost ceiling was reached.
- One keyword failed while another returned usable notes.
- Comment pagination became unavailable after earlier pages succeeded.

Check `OUTPUT.warnings` for the exact branch and page. A run fails only when it produces no useful note and encounters a failure condition.

### Running through the API

Use the standard Apify Actor endpoints, SDK clients, CLI, MCP integration, tasks, or schedules. The input and output schemas are published with the Actor so API and agent clients can discover the contract programmatically.

For recurring research, save the input as an Apify task and schedule it. Each scheduled run receives a new dataset and `OUTPUT` summary.

### Data minimization and responsible use

The Actor returns public RedNote content needed for legitimate research. It intentionally removes comment IP-location fields, provider tracking IDs, internal tokens, debug metadata, and redundant signed media variants.

RedNote data may include public creator names, IDs, avatars, posts, and comments. You are responsible for complying with RedNote's terms, copyright rules, privacy law, and any rules that apply to your use case. Do not use this Actor for harassment, surveillance, private-data collection, or unlawful profiling.

This Actor is independent and is not affiliated with, authorized by, or endorsed by Xiaohongshu/RedNote or TikHub.

### Troubleshooting

#### No notes returned

- Try a Chinese keyword.
- Change `publishedWithin` from `week` to `sixMonths` or `anytime`.
- Use `relevance` rather than a strict engagement sort.
- Check `OUTPUT.warnings` for a provider or spending-limit message.

#### The run stopped early

Increase the run's maximum charge or reduce result/comment limits. The Actor never starts a paid page when it cannot charge at least one result from that page.

#### Media URLs expire

Media URLs originate from the public platform response and may be time-limited. Use them promptly. This Actor does not download or re-host media.

### Owner deployment configuration

Customers never provide Monid credentials. The Actor owner must configure these runtime variables in Apify Console:

- `MONID_API_KEY` — mark as **Secret**.
- `MONID_WORKSPACE_ID` — mark as **Secret**.
- `MONID_MAX_RUN_COST_USD` — defaults to `1`.
- `MONID_MAX_SEARCH_PRICE_USD` — defaults to `0.015`.
- `MONID_MAX_COMMENT_PRICE_USD` — defaults to `0.015`.

Never place the Monid values in `actor.json`, build arguments, source files, README examples, logs, or public input fields.

# Actor input Schema

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

One to twenty RedNote search terms. Chinese keywords generally provide the strongest native results.

## `maxResultsPerKeyword` (type: `integer`):

Maximum normalized notes to save for each keyword.

## `sortBy` (type: `string`):

Choose how RedNote orders notes returned for each keyword.

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

Return all notes or restrict results to image, video, or live content.

## `publishedWithin` (type: `string`):

Limit results to a RedNote publication window.

## `commentMode` (type: `string`):

Choose whether to enrich no notes, the top-engagement notes, or notes in dataset order up to the safety limit.

## `maxNotesWithComments` (type: `integer`):

Global safety limit for how many returned notes receive comment enrichment.

## `maxCommentPagesPerNote` (type: `integer`):

Each page normally contains up to ten top-level comments.

## `commentSort` (type: `string`):

Order fetched top-level comments by likes or publication time.

## `includeMediaUrls` (type: `boolean`):

Include normalized cover, image, and preferred video URLs without downloading media files.

## `debug` (type: `boolean`):

Enable additional sanitized progress logs. Raw provider data and credentials are never logged.

## Actor input object example

```json
{
  "keywords": [
    "AI"
  ],
  "maxResultsPerKeyword": 20,
  "sortBy": "mostLiked",
  "noteType": "all",
  "publishedWithin": "week",
  "commentMode": "none",
  "maxNotesWithComments": 5,
  "maxCommentPagesPerNote": 1,
  "commentSort": "mostLiked",
  "includeMediaUrls": true,
  "debug": false
}
```

# Actor output Schema

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

Homogeneous note records with optional nested comments.

## `summary` (type: `string`):

Keyword statistics, warnings, endpoint prices, calls, and charges.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("yowling_blade/rednote-consumer-insights").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("yowling_blade/rednote-consumer-insights").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 '{}' |
apify call yowling_blade/rednote-consumer-insights --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RedNote (Xiaohongshu) Consumer Insights Scraper",
        "description": "Cookie-free Xiaohongshu keyword research with normalized notes, selective comments, and ready-made engagement and creator insights.",
        "version": "0.1",
        "x-build-id": "3z1rj19xeaMCapfFc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yowling_blade~rednote-consumer-insights/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yowling_blade-rednote-consumer-insights",
                "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/yowling_blade~rednote-consumer-insights/runs": {
            "post": {
                "operationId": "runs-sync-yowling_blade-rednote-consumer-insights",
                "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/yowling_blade~rednote-consumer-insights/run-sync": {
            "post": {
                "operationId": "run-sync-yowling_blade-rednote-consumer-insights",
                "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": "Keywords",
                        "minItems": 1,
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One to twenty RedNote search terms. Chinese keywords generally provide the strongest native results.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": [
                            "AI"
                        ]
                    },
                    "maxResultsPerKeyword": {
                        "title": "Maximum notes per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum normalized notes to save for each keyword.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort notes by",
                        "enum": [
                            "relevance",
                            "latest",
                            "mostLiked",
                            "mostCommented",
                            "mostCollected"
                        ],
                        "type": "string",
                        "description": "Choose how RedNote orders notes returned for each keyword.",
                        "default": "mostLiked"
                    },
                    "noteType": {
                        "title": "Note type",
                        "enum": [
                            "all",
                            "image",
                            "video",
                            "live"
                        ],
                        "type": "string",
                        "description": "Return all notes or restrict results to image, video, or live content.",
                        "default": "all"
                    },
                    "publishedWithin": {
                        "title": "Published within",
                        "enum": [
                            "anytime",
                            "day",
                            "week",
                            "sixMonths"
                        ],
                        "type": "string",
                        "description": "Limit results to a RedNote publication window.",
                        "default": "week"
                    },
                    "commentMode": {
                        "title": "Fetch comments",
                        "enum": [
                            "none",
                            "topN",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose whether to enrich no notes, the top-engagement notes, or notes in dataset order up to the safety limit.",
                        "default": "none"
                    },
                    "maxNotesWithComments": {
                        "title": "Maximum notes with comments",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Global safety limit for how many returned notes receive comment enrichment.",
                        "default": 5
                    },
                    "maxCommentPagesPerNote": {
                        "title": "Maximum comment pages per note",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Each page normally contains up to ten top-level comments.",
                        "default": 1
                    },
                    "commentSort": {
                        "title": "Sort comments by",
                        "enum": [
                            "mostLiked",
                            "latest"
                        ],
                        "type": "string",
                        "description": "Order fetched top-level comments by likes or publication time.",
                        "default": "mostLiked"
                    },
                    "includeMediaUrls": {
                        "title": "Include media URLs",
                        "type": "boolean",
                        "description": "Include normalized cover, image, and preferred video URLs without downloading media files.",
                        "default": true
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable additional sanitized progress logs. Raw provider data and credentials are never logged.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```