# Xiaohongshu Comment Keyword & Consumer Voice (`scrupulous_buckler/xiaohongshu-comment-keyword-consumer-voice`) Actor

Collect or analyze Xiaohongshu/RedNote comments and turn them into evidence-linked consumer needs, concerns, competitors, alternatives, usage scenarios, sentiment, and content opportunities.

- **URL**: https://apify.com/scrupulous\_buckler/xiaohongshu-comment-keyword-consumer-voice.md
- **Developed by:** [Peng Lyu](https://apify.com/scrupulous_buckler) (community)
- **Categories:** Social media, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / full consumer voice report

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/docs.md):

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Xiaohongshu Comment Keyword & Consumer Voice

Turn Xiaohongshu / RedNote comments into an evidence-linked consumer research report.

This Actor does more than export raw comments. It shows what consumers repeatedly ask, worry about, compare, consider as alternatives, and expect from content or products. Every conclusion keeps source comment IDs and note URLs so a researcher can audit the evidence.

### What the report includes

- comment keyword frequency and linked evidence;
- recurring consumer questions;
- needs and purchase motivations;
- concerns such as efficacy, safety, ingredients, price, usage, trust, and channels;
- known brand, product, ingredient, and competitor mentions;
- direct comparison comments and alternatives;
- usage scenarios such as commuting, travel, family, exercise, or meal timing;
- transparent cue-based sentiment distribution;
- ranked content opportunities backed by real comments;
- optional regulated-claim screening for health and other sensitive topics;
- optional normalized source-comment archive inside the report.

### Four ways to run it

#### 1. No-Cookie demo

Choose `demo` to see the full output immediately. The sample is clearly marked as demo data.

#### 2. Search a topic and analyze comments

Choose `keywordResearch`, enter a Xiaohongshu search query, and provide your own session Cookie in the secret field. The Actor finds notes, collects their comments and replies, and creates one report.

#### 3. Analyze selected notes

Choose `noteResearch`, paste note URLs or IDs, and provide your own session Cookie. Preserve `xsec_token` in shared URLs when available.

#### 4. Analyze comments you already have

Choose `uploadedComments` and paste comments from another Actor or your own file. No Cookie is required. Strings and common JSON fields such as `text`, `content`, `comment`, `commentId`, `noteId`, `noteUrl`, `authorName`, and `likes` are recognized.

### Example input: uploaded comments

```json
{
  "mode": "uploadedComments",
  "topic": "blood glucose management supplements",
  "uploadedComments": [
    {
      "commentId": "c1",
      "noteId": "n1",
      "noteUrl": "https://www.xiaohongshu.com/explore/n1",
      "text": "这个真的有效吗？和产品乙相比哪个好，有没有副作用？",
      "likes": 36
    },
    {
      "commentId": "c2",
      "noteId": "n2",
      "text": "价格贵不贵？我更想先控制饮食和运动。"
    }
  ],
  "commentKeywords": ["副作用", "价格", "饮食", "运动"],
  "knownEntities": ["产品甲", "产品乙"],
  "competitorNames": ["产品乙"],
  "regulatedTopic": true
}
````

### Pricing

**$4.99 per completed full report.** Failed collection, no-result runs, and inputs that produce no usable comments do not create the paid report event. Platform usage is included in the customer-facing event price; the developer absorbs the underlying Apify usage costs. A minimal Actor-start event may still apply as shown in the Store pricing table.

### Cookie and privacy model

- The developer does not publish or share a personal Cookie.
- Live modes use the customer's own Cookie from Apify's secret input field.
- The Cookie is never included in dataset output or application logs.
- Uploaded-comment mode and demo mode require no Cookie.
- Use only accounts, sessions, and data you are authorized to use.

### Analysis method and limitations

The first version uses deterministic, evidence-linked Chinese cue dictionaries rather than an LLM. Counts describe the collected sample, not all Xiaohongshu users. Sentiment and theme labels can be wrong or incomplete, so important decisions should be checked against the included source comments.

Live Xiaohongshu collection can fail when a session expires, a security token is missing, the platform changes an endpoint, a result is restricted, or anti-automation controls are triggered. Residential proxy and conservative limits can improve reliability but do not guarantee access.

This Actor is a research aid, not legal, medical, financial, or regulatory advice. Do not treat consumer comments as proof of product efficacy or safety.

# Actor input Schema

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

Try the demo, discover notes by keyword, analyze selected note URLs, or upload existing comments without a Cookie.

## `cookie` (type: `string`):

Required only for live keyword or note collection. It is never included in output or logs and is not shared with other users.

## `query` (type: `string`):

Required in keyword-research mode. Also becomes the topic name in the report.

## `topic` (type: `string`):

Optional clearer report title when analyzing note URLs or uploaded comments.

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

Used in selected-note mode. Preserve xsec\_token in shared URLs when available.

## `uploadedComments` (type: `array`):

Paste strings or JSON comments from another Actor. Common text/content/comment, id/commentId, noteId, noteUrl, author and like fields are recognized.

## `commentKeywords` (type: `array`):

For example: side effects, price, taste, Brand A, Brand B, ingredient names, or usage scenarios.

## `requireKeywordMatch` (type: `boolean`):

Off by default so surrounding consumer context is preserved. Turn on for strict comment-keyword filtering.

## `knownEntities` (type: `array`):

Exact names to measure in the comments. Supplying them makes brand and product attribution more reliable.

## `competitorNames` (type: `array`):

Competitor brand or product names. They are also included in known-entity analysis.

## `includeReplies` (type: `boolean`):

Collect nested replies as well as top-level comments in live modes.

## `includeSourceComments` (type: `boolean`):

Keeps the full collected sample inside the paid report for audit and export. Turn off for a smaller output row.

## `regulatedTopic` (type: `boolean`):

Adds risky-claim evidence and safer framing. This is a screening aid, not legal or medical approval.

## `maxNotes` (type: `integer`):

Maximum search results or supplied note URLs used for live collection.

## `maxCommentsPerNote` (type: `integer`):

Includes replies when reply collection is enabled.

## `maxTotalComments` (type: `integer`):

Hard cap across all notes to control run time and output size.

## `maxEvidence` (type: `integer`):

Limits source-linked consumer questions, comparisons and supporting comments.

## `maxOpportunities` (type: `integer`):

Maximum number of ranked evidence-backed content directions.

## `requestDelayMs` (type: `integer`):

A conservative delay reduces request bursts in live collection modes.

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

Residential proxy can improve live collection reliability for the customer's own authenticated session.

## Actor input object example

```json
{
  "mode": "demo",
  "noteUrls": [],
  "uploadedComments": [],
  "commentKeywords": [],
  "requireKeywordMatch": false,
  "knownEntities": [],
  "competitorNames": [],
  "includeReplies": true,
  "includeSourceComments": true,
  "regulatedTopic": false,
  "maxNotes": 10,
  "maxCommentsPerNote": 100,
  "maxTotalComments": 1000,
  "maxEvidence": 20,
  "maxOpportunities": 10,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `reports` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrupulous_buckler/xiaohongshu-comment-keyword-consumer-voice").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("scrupulous_buckler/xiaohongshu-comment-keyword-consumer-voice").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 scrupulous_buckler/xiaohongshu-comment-keyword-consumer-voice --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrupulous_buckler/xiaohongshu-comment-keyword-consumer-voice",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Xiaohongshu Comment Keyword & Consumer Voice",
        "description": "Collect or analyze Xiaohongshu/RedNote comments and turn them into evidence-linked consumer needs, concerns, competitors, alternatives, usage scenarios, sentiment, and content opportunities.",
        "version": "0.1",
        "x-build-id": "wiCXvDh6XPc26dqX6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrupulous_buckler~xiaohongshu-comment-keyword-consumer-voice/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrupulous_buckler-xiaohongshu-comment-keyword-consumer-voice",
                "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/scrupulous_buckler~xiaohongshu-comment-keyword-consumer-voice/runs": {
            "post": {
                "operationId": "runs-sync-scrupulous_buckler-xiaohongshu-comment-keyword-consumer-voice",
                "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/scrupulous_buckler~xiaohongshu-comment-keyword-consumer-voice/run-sync": {
            "post": {
                "operationId": "run-sync-scrupulous_buckler-xiaohongshu-comment-keyword-consumer-voice",
                "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": "Research mode",
                        "enum": [
                            "demo",
                            "keywordResearch",
                            "noteResearch",
                            "uploadedComments"
                        ],
                        "type": "string",
                        "description": "Try the demo, discover notes by keyword, analyze selected note URLs, or upload existing comments without a Cookie.",
                        "default": "demo"
                    },
                    "cookie": {
                        "title": "Xiaohongshu Cookie (secret)",
                        "type": "string",
                        "description": "Required only for live keyword or note collection. It is never included in output or logs and is not shared with other users."
                    },
                    "query": {
                        "title": "Topic or Xiaohongshu search keyword",
                        "type": "string",
                        "description": "Required in keyword-research mode. Also becomes the topic name in the report."
                    },
                    "topic": {
                        "title": "Report topic override",
                        "type": "string",
                        "description": "Optional clearer report title when analyzing note URLs or uploaded comments."
                    },
                    "noteUrls": {
                        "title": "Xiaohongshu note URLs or IDs",
                        "type": "array",
                        "description": "Used in selected-note mode. Preserve xsec_token in shared URLs when available.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "uploadedComments": {
                        "title": "Existing comment records",
                        "type": "array",
                        "description": "Paste strings or JSON comments from another Actor. Common text/content/comment, id/commentId, noteId, noteUrl, author and like fields are recognized.",
                        "default": []
                    },
                    "commentKeywords": {
                        "title": "Keywords to measure inside comments",
                        "type": "array",
                        "description": "For example: side effects, price, taste, Brand A, Brand B, ingredient names, or usage scenarios.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "requireKeywordMatch": {
                        "title": "Analyze only comments matching a keyword",
                        "type": "boolean",
                        "description": "Off by default so surrounding consumer context is preserved. Turn on for strict comment-keyword filtering.",
                        "default": false
                    },
                    "knownEntities": {
                        "title": "Brands, products, ingredients and alternatives",
                        "type": "array",
                        "description": "Exact names to measure in the comments. Supplying them makes brand and product attribution more reliable.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitorNames": {
                        "title": "Competitors to identify and compare",
                        "type": "array",
                        "description": "Competitor brand or product names. They are also included in known-entity analysis.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReplies": {
                        "title": "Include reply threads",
                        "type": "boolean",
                        "description": "Collect nested replies as well as top-level comments in live modes.",
                        "default": true
                    },
                    "includeSourceComments": {
                        "title": "Include normalized source comments in the report",
                        "type": "boolean",
                        "description": "Keeps the full collected sample inside the paid report for audit and export. Turn off for a smaller output row.",
                        "default": true
                    },
                    "regulatedTopic": {
                        "title": "Regulated health or other sensitive topic",
                        "type": "boolean",
                        "description": "Adds risky-claim evidence and safer framing. This is a screening aid, not legal or medical approval.",
                        "default": false
                    },
                    "maxNotes": {
                        "title": "Maximum notes to analyze",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum search results or supplied note URLs used for live collection.",
                        "default": 10
                    },
                    "maxCommentsPerNote": {
                        "title": "Maximum comments per note",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Includes replies when reply collection is enabled.",
                        "default": 100
                    },
                    "maxTotalComments": {
                        "title": "Maximum comments in one report",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap across all notes to control run time and output size.",
                        "default": 1000
                    },
                    "maxEvidence": {
                        "title": "Maximum evidence excerpts per report section",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limits source-linked consumer questions, comparisons and supporting comments.",
                        "default": 20
                    },
                    "maxOpportunities": {
                        "title": "Maximum content opportunities",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum number of ranked evidence-backed content directions.",
                        "default": 10
                    },
                    "requestDelayMs": {
                        "title": "Delay between comment pages",
                        "minimum": 500,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "A conservative delay reduces request bursts in live collection modes.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy can improve live collection reliability for the customer's own authenticated session.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
