# Bilibili Scraper (`automation-lab/bilibili-scraper`) Actor

Scrape Bilibili videos, creators, search results, engagement metrics, and optional comments for China social intelligence.

- **URL**: https://apify.com/automation-lab/bilibili-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Bilibili Scraper

Scrape public Bilibili videos, creators, search results, engagement metrics, and optional comments from China's major social video platform.

### What does Bilibili Scraper do?

Bilibili Scraper turns public Bilibili pages and search keywords into structured Apify dataset rows.

It can collect:

- 🎬 Video titles and descriptions
- 👤 Creator names and creator IDs
- 📈 Views, likes, coins, favorites, shares, replies, and danmaku counts
- 🏷️ Tags, categories, cover images, and publish dates
- 🔎 Search result videos for a keyword
- 💬 Optional top-level comment samples

### Who is it for?

This actor is useful for teams that monitor Chinese social video content. Common personas include:

#### 📣 Brand and agency teams

- Track campaign visibility for product, game, entertainment, or creator keywords.
- Compare public engagement across branded videos and competitor content.

#### 🧭 Market research and competitive intelligence teams

- Study creator performance, content themes, and audience response in China-focused research.
- Build repeatable keyword monitors for launches, categories, and cultural moments.

#### 🧪 Data, AI, and analytics teams

- Create structured public video datasets for dashboards, enrichment, and internal models.
- Combine video metrics with comment samples for social listening and trend analysis.

#### 🛍️ E-commerce and creator partnership teams

- Discover creators and videos that mention product categories or target brands.
- Score potential KOL opportunities using public views, likes, coins, favorites, and replies.

### Why use it?

Bilibili has unique engagement signals such as coins, favorites, danmaku counts, and active comment threads.

This actor helps you collect those public signals without building your own Bilibili API integration.

### Common use cases

- Find Bilibili videos for a keyword such as a product, game, brand, or topic
- Monitor creator performance and video engagement over time
- Collect comment samples for qualitative social listening
- Build lead lists of creators for KOL discovery
- Compare competitor content traction in China-focused campaigns

### Data you can extract

| Field | Description |
| --- | --- |
| `bvid` | Bilibili BV video identifier |
| `aid` | Numeric AV/video id |
| `title` | Public video title |
| `description` | Public video description |
| `creatorName` | Uploader name |
| `creatorId` | Uploader id |
| `createdAt` | Publication timestamp |
| `durationSeconds` | Video length in seconds |
| `viewCount` | View count |
| `likeCount` | Like count |
| `coinCount` | Coin count |
| `favoriteCount` | Favorite count |
| `shareCount` | Share count |
| `replyCount` | Reply/comment count |
| `danmakuCount` | Danmaku/bullet-comment count |
| `tags` | Public tags when available |
| `comments` | Optional top-level comment sample |

### How much does it cost to scrape Bilibili videos?

The actor uses pay-per-event pricing.

- A small start event is charged once per run: **$0.005**.
- A result event is charged for each Bilibili video row saved.
- Optional comment samples are included in the same video row charge.

Example gross estimates before Apify plan discounts:

| Run size | Start event | FREE result tier | BRONZE result tier | Approx. total on BRONZE |
| --- | ---: | ---: | ---: | ---: |
| 10 videos | $0.005 | $0.000078287 each | $0.000068075 each | ~$0.0057 |
| 100 videos | $0.005 | $0.000078287 each | $0.000068075 each | ~$0.0118 |
| 1,000 videos | $0.005 | $0.000078287 each | $0.000068075 each | ~$0.0731 |

Higher Apify usage tiers receive lower per-result prices: SILVER, GOLD, PLATINUM, and DIAMOND are progressively cheaper. Apify shows the exact estimated cost before you start a run.

### Input options

You can use video URLs, search keywords, or both.

```json
{
  "videoUrls": [
    { "url": "https://www.bilibili.com/video/BV1xx411c7mD" }
  ],
  "searchQueries": ["Python"],
  "maxResults": 10,
  "includeComments": false,
  "maxCommentsPerVideo": 3
}
````

### Video URL scraping

Use `videoUrls` when you already know which Bilibili pages you need.

The actor supports common Bilibili video formats:

- `https://www.bilibili.com/video/BV...`
- `https://www.bilibili.com/video/av...`
- URLs with `bvid=` or `aid=` parameters

### Search scraping

Use `searchQueries` to discover public Bilibili videos by keyword.

The actor searches Bilibili video results and then enriches each result with detail metrics.

Tips:

- Keep `maxResults` low for quick tests.
- Use Chinese keywords when your target market is China-specific.
- Run separate keywords if you want easier dataset filtering.

### Comments

Set `includeComments` to `true` to include top-level comment samples.

Each comment object can include:

- `commentId`
- `authorName`
- `authorId`
- `text`
- `createdAt`
- `likeCount`
- `replyCount`

For large-scale comment exports, keep `maxCommentsPerVideo` modest to avoid unnecessary runtime.

### Output example

```json
{
  "sourceType": "search",
  "searchKeyword": "Python",
  "bvid": "BV1rpWjevEip",
  "aid": 113006243481679,
  "title": "Python tutorial",
  "creatorName": "Python官方课程",
  "viewCount": 16890907,
  "likeCount": 320000,
  "coinCount": 12000,
  "favoriteCount": 670203,
  "replyCount": 1000,
  "pageUrl": "https://www.bilibili.com/video/BV1rpWjevEip",
  "comments": []
}
```

### How to run

1. Open the actor on Apify.
2. Add one or more Bilibili video URLs, search keywords, or both.
3. Choose `maxResults`.
4. Enable comments only if you need comment samples.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

- Start with 5-10 results when testing a new keyword.
- Use exact brand names and creator names for cleaner search results.
- Use direct URLs for known videos because they avoid search ambiguity.
- Enable comments only when comments are part of your analysis.
- Re-run the same input periodically to track metric changes.

### Integrations

You can connect the dataset to many workflows:

- Send rows to Google Sheets for analyst review.
- Push results to a warehouse for time-series tracking.
- Feed creator and engagement data into lead scoring.
- Use comments as public social listening samples.
- Trigger alerts when a keyword produces high-engagement videos.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bilibili-scraper').call({
  searchQueries: ['Python'],
  maxResults: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bilibili-scraper').call(run_input={
    'searchQueries': ['Python'],
    'maxResults': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~bilibili-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["Python"],"maxResults":10}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, and other MCP-compatible tools through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/bilibili-scraper
```

Add it with Claude Code:

```bash
claude mcp add --transport http apify-bilibili-scraper https://mcp.apify.com?tools=automation-lab/bilibili-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-bilibili-scraper": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bilibili-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the top 10 Bilibili videos for this keyword and summarize creator engagement."
- "Collect public metrics for these Bilibili video URLs."
- "Find Bilibili videos about this game launch and rank by likes."

### What the actor does not do

- It does not download videos or audio.
- It does not bypass login-only or private data.
- It does not scrape private user information.
- It does not guarantee Bilibili search ranking remains identical over time.
- It does not provide a full historical metric archive unless you schedule repeated runs.

### Reliability notes

The actor uses public Bilibili HTTP endpoints with browser-like headers.

If Bilibili temporarily rate-limits or changes an endpoint, retry later or reduce run size.

### FAQ

#### I got fewer results than requested. Why?

Bilibili may return fewer public results for a keyword, duplicate videos may be skipped, or some detail pages may be unavailable.

#### Why are comments empty?

Comments can be disabled, unavailable, removed, or not requested. Enable `includeComments` and keep `maxCommentsPerVideo` above zero.

#### Why is a field null?

Some videos do not expose every metric or metadata field through the public API. Null values mean the field was not available for that video.

### Scheduling

Schedule the actor to run daily or weekly to track engagement changes for keywords or known videos.

Use the same input to create a consistent monitoring dataset.

### Legality

This actor extracts publicly available data from Bilibili. You are responsible for using the data in accordance with Bilibili terms, applicable privacy laws, and your own compliance requirements.

Do not use the actor for spam, harassment, or attempts to access private data.

### Related scrapers

Use these with Bilibili Scraper for broader social intelligence:

- https://apify.com/automation-lab/tiktok-scraper
- https://apify.com/automation-lab/douyin-scraper
- https://apify.com/automation-lab/youtube-scraper

### Changelog

#### 0.1

Initial release with video URL scraping, keyword search, engagement metrics, creator fields, and optional comments.

### Support

If a run fails or output looks wrong, open an issue with:

- The input you used
- The run ID
- A short description of the expected result
- A sample URL or keyword

### Field reference

The dataset schema is optimized for video intelligence analysis.

All count fields are numbers when available.

All timestamps are ISO strings when available.

URLs are normalized to HTTPS when possible.

### Performance guidance

HTTP runs are lightweight.

For quick checks, use 5-10 results.

For realistic monitoring, use 50-200 results per keyword group.

For comment sampling, keep comment limits low unless comments are central to your use case.

# Actor input Schema

## `videoUrls` (type: `array`):

Direct Bilibili video pages to scrape. Supports BV and AV video URLs.

## `searchQueries` (type: `array`):

Keywords to search on Bilibili. The actor collects matching public videos until maxResults is reached.

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

Maximum number of video rows to save across URLs and search keywords.

## `includeComments` (type: `boolean`):

Add a small sample of top-level public comments to each video row.

## `maxCommentsPerVideo` (type: `integer`):

Top-level comments to include per video when comments are enabled. Keep low for faster runs.

## Actor input object example

```json
{
  "videoUrls": [
    {
      "url": "https://www.bilibili.com/video/BV1xx411c7mD"
    }
  ],
  "searchQueries": [
    "Python"
  ],
  "maxResults": 10,
  "includeComments": false,
  "maxCommentsPerVideo": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "videoUrls": [
        {
            "url": "https://www.bilibili.com/video/BV1xx411c7mD"
        }
    ],
    "searchQueries": [
        "Python"
    ],
    "maxResults": 10,
    "includeComments": false,
    "maxCommentsPerVideo": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bilibili-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 = {
    "videoUrls": [{ "url": "https://www.bilibili.com/video/BV1xx411c7mD" }],
    "searchQueries": ["Python"],
    "maxResults": 10,
    "includeComments": False,
    "maxCommentsPerVideo": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bilibili-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 '{
  "videoUrls": [
    {
      "url": "https://www.bilibili.com/video/BV1xx411c7mD"
    }
  ],
  "searchQueries": [
    "Python"
  ],
  "maxResults": 10,
  "includeComments": false,
  "maxCommentsPerVideo": 3
}' |
apify call automation-lab/bilibili-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bilibili Scraper",
        "description": "Scrape Bilibili videos, creators, search results, engagement metrics, and optional comments for China social intelligence.",
        "version": "0.1",
        "x-build-id": "NzQYh87aIcp5neUeh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bilibili-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bilibili-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/automation-lab~bilibili-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bilibili-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/automation-lab~bilibili-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bilibili-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "videoUrls": {
                        "title": "Bilibili video URLs",
                        "type": "array",
                        "description": "Direct Bilibili video pages to scrape. Supports BV and AV video URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search on Bilibili. The actor collects matching public videos until maxResults is reached.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of video rows to save across URLs and search keywords.",
                        "default": 25
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Add a small sample of top-level public comments to each video row.",
                        "default": false
                    },
                    "maxCommentsPerVideo": {
                        "title": "Maximum comments per video",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Top-level comments to include per video when comments are enabled. Keep low for faster runs.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```