# Bilibili Video Search Scraper (`fetch_cat/bilibili-video-search-scraper`) Actor

Scrape public Bilibili video search results, BVIDs, creator details, stats, tags, thumbnails, and metadata for research workflows.

- **URL**: https://apify.com/fetch\_cat/bilibili-video-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 item extracteds

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 Video Search Scraper

Scrape public Bilibili video search results and video metadata by keyword, BVID, or video URL.

Use this actor to monitor topics, creators, brands, products, media launches, and content trends on Bilibili without building your own data collection workflow.

### What does Bilibili Video Search Scraper do?

Bilibili Video Search Scraper turns Bilibili search pages and video identifiers into structured dataset rows.

It can collect videos from keyword searches, direct BVID identifiers, and Bilibili video URLs.

For each video, it returns useful catalog and performance fields such as title, URL, creator, publication date, thumbnail, duration, category, views, likes, favorites, danmaku counts, shares, tags, and timestamps.

### Who is it for?

- 🎯 Market researchers tracking China video trends.
- 📣 Brand teams monitoring mentions and campaigns.
- 🧠 Social intelligence teams following topics and creators.
- 🎬 Media analysts comparing video performance.
- 🛒 E-commerce teams watching product discovery content.
- 🧪 Data teams feeding dashboards, alerts, or enrichment pipelines.

### Why use this actor?

- 🔎 Search Bilibili by one or many keywords.
- 🔗 Add direct BVIDs or video URLs when you already know target videos.
- 📊 Export normalized video statistics into JSON, CSV, Excel, XML, or HTML.
- 🧩 Connect results to Apify integrations, webhooks, APIs, and MCP workflows.
- ⚙️ Control sort order, page limits, maximum videos, and metadata enrichment.

### What data can you extract?

| Field | Description |
| --- | --- |
| `keyword` | Keyword that produced the video result |
| `rank` | Rank within that keyword search |
| `title` | Video title |
| `bvid` | Bilibili video identifier |
| `aid` | Numeric archive ID when available |
| `url` | Canonical Bilibili video URL |
| `author` | Creator display name |
| `mid` | Creator member ID |
| `description` | Video description |
| `publishedAt` | Publication time in ISO format |
| `thumbnailUrl` | Video thumbnail URL |
| `category` | Video category |
| `durationSeconds` | Duration in seconds |
| `viewCount` | View count |
| `danmakuCount` | Danmaku comment count |
| `likeCount` | Like count |
| `coinCount` | Coin count |
| `favoriteCount` | Favorite count |
| `shareCount` | Share count |
| `replyCount` | Reply count |
| `tags` | Public video tags |
| `scrapedAt` | Collection timestamp |

### How much does it cost to scrape Bilibili video search results?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-video fee for each saved dataset item.

The default input is intentionally small so a first test run stays inexpensive.

For larger monitoring jobs, increase `maxItems` gradually and review the run cost in Apify Console.

### How to use Bilibili Video Search Scraper

1. Open the actor on Apify.
2. Add one or more Bilibili search keywords.
3. Optionally add BVIDs or Bilibili video URLs.
4. Choose a maximum number of videos.
5. Select a sort order if relevance is not enough.
6. Run the actor.
7. Export the dataset or connect it to your workflow.

### Input example

```json
{
  "keywords": ["python", "openai"],
  "bvids": ["BV1rpWjevEip"],
  "maxItems": 50,
  "sort": "totalrank",
  "maxPagesPerKeyword": 3,
  "includeDetails": true,
  "requestDelayMillis": 700
}
````

### Input fields

#### `keywords`

Search terms to collect Bilibili videos for.

Examples:

- `python`
- `openai`
- `游戏`
- `product launch`
- a brand name

#### `bvids`

Direct Bilibili video identifiers or URLs.

Examples:

- `BV1rpWjevEip`
- `https://www.bilibili.com/video/BV1rpWjevEip`

#### `maxItems`

Total maximum number of videos to save across all keyword and direct inputs.

#### `sort`

Controls Bilibili search ordering.

Supported values:

- `totalrank` — relevance
- `click` — most viewed
- `pubdate` — newest
- `dm` — most danmaku comments
- `stow` — most favorites

#### `maxPagesPerKeyword`

Safety cap for pagination per keyword.

Each search page usually contains up to 20 videos.

#### `includeDetails`

When enabled, the actor enriches videos with detailed public metadata such as normalized stats, tags, pages, and richer descriptions.

#### `requestDelayMillis`

Delay between requests.

Use a higher value for large keyword batches if you want a more conservative run.

### Output example

```json
{
  "keyword": "python",
  "rank": 1,
  "page": 1,
  "sort": "totalrank",
  "sourceType": "search",
  "title": "Python tutorial video",
  "bvid": "BV1rpWjevEip",
  "aid": 113006243481679,
  "url": "https://www.bilibili.com/video/BV1rpWjevEip",
  "author": "Creator name",
  "mid": 3546597933714079,
  "description": "Video description",
  "publishedAt": "2024-08-22T14:59:18.000Z",
  "thumbnailUrl": "https://i2.hdslb.com/example.jpg",
  "category": "Technology",
  "durationSeconds": 120,
  "viewCount": 100000,
  "danmakuCount": 500,
  "likeCount": 1000,
  "coinCount": 200,
  "favoriteCount": 300,
  "shareCount": 50,
  "replyCount": 80,
  "tags": ["Python", "教程"],
  "scrapedAt": "2026-06-28T08:00:00.000Z"
}
```

### Tips for better results

- Use Chinese and English keywords when researching international topics.
- Start with `totalrank` for discovery.
- Use `pubdate` for freshness monitoring.
- Use direct BVIDs when you need known videos only.
- Keep `includeDetails` enabled when you need tags or full stats.
- Lower `maxItems` for test runs.
- Increase `requestDelayMillis` for large jobs.

### Common use cases

- 📈 Track video popularity around a campaign.
- 🏷️ Monitor brand mentions on Bilibili.
- 🎮 Discover gaming and entertainment videos.
- 🧑‍🏫 Collect education content metadata.
- 🧭 Build a topic intelligence dashboard.
- 🔔 Trigger alerts when new high-performing videos appear.

### Integrations

You can connect the dataset to:

- Google Sheets for manual review.
- Make or Zapier for no-code automations.
- Webhooks for event-driven alerts.
- Apify datasets API for analytics pipelines.
- BI tools that ingest CSV or JSON.
- Vector databases for content discovery workflows.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/bilibili-video-search-scraper').call({
  keywords: ['python'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/bilibili-video-search-scraper').call(run_input={
    'keywords': ['python'],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~bilibili-video-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["python"],"maxItems":20}'
```

### MCP integration

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

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/bilibili-video-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-bilibili "https://mcp.apify.com/?tools=fetch_cat/bilibili-video-search-scraper"
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Find the top Bilibili videos about Python and summarize the creators."
- "Collect the newest Bilibili videos mentioning my product name."
- "Compare view counts for these Bilibili BVIDs."

### Data exports

After a run finishes, you can export results as:

- JSON
- CSV
- Excel
- XML
- HTML table
- RSS-compatible downstream transformations

### Scheduling

Use Apify schedules to run the actor daily, weekly, or hourly.

Common scheduled workflows:

- Daily keyword monitoring.
- Weekly creator tracking.
- Campaign launch monitoring.
- Competitor content review.

### Webhooks

Add a webhook to send results to your application after every successful run.

Typical webhook events:

- Run succeeded.
- Run failed.
- Dataset ready for processing.

### Limits and reliability

Bilibili may adjust public availability, rate limits, and result ranking.

Use moderate request delays for large batches.

If a keyword returns fewer results than expected, try a broader keyword or a different sort order.

### FAQ

#### Can I use this actor through the API?

Yes. Use the Apify API, SDKs, or MCP Server examples above to run the actor and read the default dataset.

#### Is this an alternative to a full Bilibili analytics platform?

It is best for extracting public video search and metadata into your own tools. It does not replace private account analytics.

#### Does this actor need my Bilibili login?

No. The actor is designed for public video metadata and does not ask for credentials.

### Troubleshooting

#### Why did I get fewer videos than `maxItems`?

The source may have fewer available results for the selected keyword and sorting option, or the page cap may have been reached.

Increase `maxPagesPerKeyword` or add more keywords.

#### Why are some fields empty?

Some videos do not expose every statistic or category in every context.

Enable `includeDetails` for the richest metadata.

#### Why are results different from what I see in a browser?

Search rankings can vary by time, location, personalization, and Bilibili's own ranking updates.

### Legality

This actor collects publicly available metadata.

You are responsible for using the output in accordance with applicable laws, platform terms, and privacy rules.

Do not use scraped data for spam, harassment, or unlawful profiling.

### Related scrapers

More actors from this developer:

- https://apify.com/fetch\_cat/google-scholar-profiles-scraper
- https://apify.com/fetch\_cat/hacker-news-search-scraper
- https://apify.com/fetch\_cat/bluesky-profile-feed-scraper

### Support

If you need help, open an issue on the actor page and include:

- Run ID
- Input JSON
- Expected result
- What looked wrong

### Changelog

#### 0.1

Initial version with keyword search, direct BVID/video URL enrichment, detailed video statistics, tags, and configurable sorting.

# Actor input Schema

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

Bilibili search terms to collect videos for. Example: python, game trailer, brand name.

## `bvids` (type: `array`):

Optional direct Bilibili BVIDs or video URLs to fetch, e.g. BV1rpWjevEip or https://www.bilibili.com/video/BV...

## `maxItems` (type: `integer`):

Total maximum videos to save across all keywords and direct BVIDs.

## `sort` (type: `string`):

Bilibili search ordering to use for keyword results.

## `maxPagesPerKeyword` (type: `integer`):

Pagination safety cap for each keyword. Each Bilibili page usually returns up to 20 videos.

## `includeDetails` (type: `boolean`):

When enabled, fetches each video's public detail endpoint for richer stats, tags, pages, and normalized metadata.

## `requestDelayMillis` (type: `integer`):

Conservative delay between Bilibili API requests. Increase if you process large keyword batches.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "bvids": [],
  "maxItems": 20,
  "sort": "totalrank",
  "maxPagesPerKeyword": 3,
  "includeDetails": true,
  "requestDelayMillis": 700
}
```

# 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 = {
    "keywords": [
        "python"
    ],
    "bvids": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/bilibili-video-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["python"],
    "bvids": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/bilibili-video-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "python"
  ],
  "bvids": []
}' |
apify call fetch_cat/bilibili-video-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bilibili Video Search Scraper",
        "description": "Scrape public Bilibili video search results, BVIDs, creator details, stats, tags, thumbnails, and metadata for research workflows.",
        "version": "0.1",
        "x-build-id": "S00aohe2kgdqNyH5v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~bilibili-video-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-bilibili-video-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~bilibili-video-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-bilibili-video-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~bilibili-video-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-bilibili-video-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Bilibili search terms to collect videos for. Example: python, game trailer, brand name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "bvids": {
                        "title": "BVIDs or video URLs",
                        "type": "array",
                        "description": "Optional direct Bilibili BVIDs or video URLs to fetch, e.g. BV1rpWjevEip or https://www.bilibili.com/video/BV...",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum videos",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Total maximum videos to save across all keywords and direct BVIDs.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Search sort order",
                        "enum": [
                            "totalrank",
                            "click",
                            "pubdate",
                            "dm",
                            "stow"
                        ],
                        "type": "string",
                        "description": "Bilibili search ordering to use for keyword results.",
                        "default": "totalrank"
                    },
                    "maxPagesPerKeyword": {
                        "title": "Maximum pages per keyword",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Pagination safety cap for each keyword. Each Bilibili page usually returns up to 20 videos.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Fetch detailed video stats and tags",
                        "type": "boolean",
                        "description": "When enabled, fetches each video's public detail endpoint for richer stats, tags, pages, and normalized metadata.",
                        "default": true
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Conservative delay between Bilibili API requests. Increase if you process large keyword batches.",
                        "default": 700
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```