# Wildberries Scraper - Russian Marketplace Product Data (`haketa/wildberries-scraper`) Actor

Scrape Wildberries.ru products by keyword: name, brand, RUB prices, ratings, reviews, supplier details, delivery times, color and size variants. Russian e-commerce data, marketplace intelligence, supplier discovery and lead generation.

- **URL**: https://apify.com/haketa/wildberries-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

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

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

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


# README

## Wildberries Scraper — Russian Marketplace Product Data & Lead Generation

Extract comprehensive product data from **Wildberries.ru** — Russia's largest online marketplace with over 250 million products across 50,000+ brands. Scrape product name, brand, prices (basic & discounted), rating, review count, supplier details, delivery times, color variants, size options, and more. Perfect for e-commerce competitive intelligence, marketplace research, supplier discovery, price monitoring, and lead generation on the Russian market.

### 🎯 Key Differentiators

- **30+ data fields per product** — far more than basic scrapers that only extract name and price
- **Internal JSON API** — extracts data directly from the same endpoint the Wildberries website uses, giving you the complete dataset including delivery times, supplier IDs, review metrics, and taxonomy
- **Supplier discovery** — get supplier name, ID, and rating for every product — identify manufacturers and distributors selling on Russia's #1 marketplace
- **Delivery time data** — min/max delivery days per warehouse, logistics cost breakdown
- **Size & color variants** — all available options with per-variant pricing
- **Discount calculation** — automatic discount percentage computed from basic vs. discounted price
- **No login required** — all data is publicly accessible through Wildberries' catalog search
- **Sort options** — popular, rating, price ascending/descending, newest first

### 📊 What You Can Extract

| Field | Description | Example |
|-------|-------------|---------|
| `name` | Product name | "Ноутбук Lenovo IdeaPad 3" |
| `brand` | Brand name | "Lenovo" |
| `brandId` | Wildberries brand ID | 123456 |
| `priceBasicRub` | Original price (RUB) | 59990 |
| `priceProductRub` | Discounted price (RUB) | 39990 |
| `discountPercent` | Calculated discount % | 33 |
| `rating` | Star rating (0-5) | 4.7 |
| `feedbacks` | Number of reviews | 1243 |
| `reviewRating` | Weighted review rating | 4.8 |
| `totalQuantity` | Available stock | 250 |
| `supplier` | Supplier/merchant name | "ООО ТехноМаркет" |
| `supplierId` | Wildberries supplier ID | 987654 |
| `supplierRating` | Supplier rating | 4.9 |
| `subjectId` | Category ID | 654 |
| `colors` | Available colors | [{"name":"black","id":0}] |
| `sizeVariants` | Size options with pricing | [{"name":"42","priceProductRub":39990}] |
| `deliveryDaysMin` | Minimum delivery days | 1 |
| `deliveryDaysMax` | Maximum delivery days | 3 |
| `priceLogisticsRub` | Logistics cost (RUB) | 300 |
| `priceReturnRub` | Return cost (RUB) | 0 |
| `mainImage` | Product image URL | basket-01.wbbasket.ru/vol.../big/1.webp |
| `productUrl` | Wildberries product page | wildberries.ru/catalog/123/detail.aspx |
| `searchQuery` | Search keyword used | "ноутбук" |

### 🚀 Use Cases

#### E-Commerce Competitive Intelligence
Track competitor pricing, product assortment, and discount strategies across the entire Russian marketplace. Monitor how brands and suppliers position themselves on Russia's dominant e-commerce platform.

#### Supplier & Manufacturer Discovery
Wildberries hosts thousands of suppliers — from major Russian manufacturers to Chinese dropshippers. Extract supplier names, IDs, and ratings to build B2B lead lists for sourcing, wholesale, or partnership opportunities in the Russian/CIS market.

#### Price Monitoring & MAP Compliance
Track product prices and discounts over time. Monitor if resellers are undercutting your MAP (Minimum Advertised Price). Calculate discount depth across categories and competitors.

#### Market Research & Category Analysis
Analyze entire product categories: average prices, rating distributions, most-reviewed products, dominant brands, and active suppliers. Understand the competitive landscape before entering the Russian market.

#### Lead Generation for B2B Services
Extract supplier data to identify merchants who may need logistics, warehousing, marketing, photography, or financial services. Filter by category to target specific verticals.

#### Product Feed Enrichment
Enrich your product database with accurate, up-to-date Wildberries data — current prices, stock levels, ratings, and review counts.

### 📥 Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `queries` | String array | ✅ Yes | Search keywords (e.g. `["ноутбук", "платье", "стол"]`). Supports Russian and English. |
| `maxItemsPerQuery` | Integer | No (default: 200) | Maximum products to collect per keyword. ~100 per page. |
| `sort` | Enum | No (default: `popular`) | Sort order: `popular`, `rate` (by rating), `priceup` (cheapest first), `pricedown` (expensive first), `newly` (newest first) |
| `language` | Enum | No (default: `ru`) | Interface language: `ru` (Russian, native names), `en` (English translations) |
| `proxyConfiguration` | Object | No (default: Residential) | Proxy settings. Residential with Russian IP recommended for production. |

### 💰 Pricing & Performance

Wildberries Scraper uses Playwright browser automation to handle the anti-bot challenge, then intercepts the internal JSON API for high-speed data extraction.

- **Cost efficiency**: Each page returns up to 100 products in a single JSON response — no DOM parsing overhead
- **Proxy recommendation**: Residential proxy with Russian IP for reliable operation. Datacenter proxies may trigger anti-bot challenges
- **Speed**: ~5-15 seconds per page depending on proxy latency and anti-bot challenge clearance
- **Memory**: 1024 MB minimum, 4096 MB recommended for high-volume runs

### 🛡️ Anti-Bot Handling

Wildberries uses **wbaas** — an in-house anti-bot system that serves HTTP 498 challenges to suspicious traffic. This scraper handles it through:

1. **Browser fingerprinting** — Crawlee's fingerprint generator creates realistic Chrome browser profiles
2. **JavaScript execution** — Playwright runs the full browser environment, including any client-side challenges
3. **Session persistence** — Cookies and tokens are maintained across page navigations within a run
4. **Proxy rotation** — Residential proxy support distributes requests across clean IPs

For production runs targeting 1,000+ products, residential proxies with Russian exit nodes provide the most reliable path.

### 📋 Example Output

```json
{
  "id": 776264265,
  "name": "Curling Tongs",
  "brand": "LOKKA",
  "brandId": 312269064,
  "priceBasicRub": 4000,
  "priceProductRub": 3036,
  "discountPercent": 24,
  "priceLogisticsRub": 0,
  "priceReturnRub": 0,
  "rating": 5,
  "feedbacks": 136,
  "reviewRating": 4.8,
  "totalQuantity": 120762,
  "supplier": "LOKKA",
  "supplierId": 250088821,
  "supplierRating": 5,
  "subjectId": 654,
  "subjectParentId": 9214,
  "root": 800442163,
  "kindId": 0,
  "volume": 34,
  "pics": 30,
  "mainImage": "https://basket-01.wbbasket.ru/vol776/part776264/776264265/images/big/1.webp",
  "colors": [{"name": "pink", "id": 16761035}],
  "sizeVariants": [{
    "name": "",
    "priceBasicRub": 4000,
    "priceProductRub": 3036,
    "deliveryDaysMin": 2,
    "deliveryDaysMax": 19,
    "optionId": 1139194125
  }],
  "deliveryDaysMin": 2,
  "deliveryDaysMax": 19,
  "productUrl": "https://www.wildberries.ru/catalog/776264265/detail.aspx",
  "searchQuery": "lokka",
  "sortOrder": "popular",
  "scrapedAt": "2026-06-24T12:00:00.000Z"
}
````

### 🏗️ Technical Architecture

This scraper is built on:

- **[Crawlee](https://crawlee.dev)** — Apify's open-source scraping framework with built-in fingerprinting, session management, and proxy rotation
- **[Playwright](https://playwright.dev)** — Microsoft's browser automation library for handling JavaScript challenges
- **[Apify SDK](https://docs.apify.com/sdk/js)** — Cloud platform integration for storage, proxy, and deployment

The extraction flow:

1. Playwright launches a browser with realistic fingerprint
2. Navigates to Wildberries search page with your keyword and sort parameters
3. Waits for the website's JavaScript to complete anti-bot challenges
4. Intercepts the internal JSON API response (`__internal/u-search`)
5. Extracts all 30+ product fields from the structured data
6. Auto-paginates until max items reached or results exhausted
7. Deduplicates by product ID to prevent duplicates across pages

### 🔍 Tips for Best Results

- **Use Russian keywords** for the most complete results. Russian-language queries return the full Wildberries catalog. English queries also work but may return fewer results.
- **Combine with other data sources** — use this scraper alongside Ozon or Yandex Market scrapers for complete Russian e-commerce coverage.
- **Sort by `rate`** to get the highest-rated products first.
- **Sort by `pricedown`** to analyze premium/luxury segments of a category.
- **Sort by `priceup`** to find budget options and entry-level products.
- **Run regularly** to track price changes, new product launches, and rating trends over time.

### ⚙️ Running on Apify

1. Click "Try for free"
2. Enter your search keywords in the `queries` field
3. Set `maxItemsPerQuery` to your desired limit
4. Choose a `sort` order if needed
5. Click "Save & Run"

The actor will process each keyword, paginate automatically, and save all products to the dataset. Download as JSON, CSV, Excel, or access via API.

### 📚 Related Actors

- **Ozon Scraper** — Russia's #2 marketplace
- **Yandex Market Scraper** — Price comparison across Russian retailers
- **Allegro Scraper** — Polish marketplace (CEE region)
- **Amazon Product Scraper** — Global marketplace benchmark

### ⚠️ Legal & Responsible Use

This scraper extracts publicly available product data from Wildberries.ru. It is designed for competitive intelligence, market research, and supplier discovery purposes.

Users are responsible for:

- Complying with Wildberries' Terms of Service
- Respecting rate limits and not overwhelming the website
- Not scraping personal data or user-generated content beyond public product listings
- Complying with applicable data protection laws (GDPR, Russian Federal Law No. 152-FZ)
- Ensuring your use case aligns with fair use principles

***

Built with ❤️ for the e-commerce and marketplace intelligence community. Questions? Contact the developer through Apify.

# Actor input Schema

## `queries` (type: `array`):

Product search terms as typed into Wildberries search (e.g. "ноутбук", "платье", "стол"). Supports Russian or English queries.

## `maxItemsPerQuery` (type: `integer`):

Maximum products to collect per keyword. ~100 products per page, paginated automatically up to 100 pages.

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

Sorting: popular (default), rate (by rating), priceup (cheapest first), pricedown (most expensive first), newly (newest first).

## `language` (type: `string`):

Language for the Wildberries interface. Affects product name translation. 'ru' for Russian (native), 'en' for English.

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

Wildberries uses wbaas anti-bot protection. Residential proxy with Russian IP recommended for production runs. Datacenter may work for small tests but risks 498 blocks.

## Actor input object example

```json
{
  "queries": [
    "ноутбук",
    "платье",
    "наушники"
  ],
  "maxItemsPerQuery": 100,
  "sort": "popular",
  "language": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Clean JSON array of every scraped product with all fields.

## `productsCsv` (type: `string`):

Spreadsheet-ready CSV export.

## `dataset` (type: `string`):

Default dataset of this run.

# 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 = {
    "queries": [
        "ноутбук"
    ],
    "maxItemsPerQuery": 100,
    "sort": "popular",
    "language": "ru",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/wildberries-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 = {
    "queries": ["ноутбук"],
    "maxItemsPerQuery": 100,
    "sort": "popular",
    "language": "ru",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/wildberries-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 '{
  "queries": [
    "ноутбук"
  ],
  "maxItemsPerQuery": 100,
  "sort": "popular",
  "language": "ru",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call haketa/wildberries-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wildberries Scraper - Russian Marketplace Product Data",
        "description": "Scrape Wildberries.ru products by keyword: name, brand, RUB prices, ratings, reviews, supplier details, delivery times, color and size variants. Russian e-commerce data, marketplace intelligence, supplier discovery and lead generation.",
        "version": "1.0",
        "x-build-id": "BhwTV4LcfK1tTDyRD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~wildberries-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-wildberries-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/haketa~wildberries-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-wildberries-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/haketa~wildberries-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-wildberries-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Product search terms as typed into Wildberries search (e.g. \"ноутбук\", \"платье\", \"стол\"). Supports Russian or English queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum products to collect per keyword. ~100 products per page, paginated automatically up to 100 pages.",
                        "default": 200
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "popular",
                            "rate",
                            "priceup",
                            "pricedown",
                            "newly"
                        ],
                        "type": "string",
                        "description": "Sorting: popular (default), rate (by rating), priceup (cheapest first), pricedown (most expensive first), newly (newest first).",
                        "default": "popular"
                    },
                    "language": {
                        "title": "Interface language",
                        "enum": [
                            "ru",
                            "en"
                        ],
                        "type": "string",
                        "description": "Language for the Wildberries interface. Affects product name translation. 'ru' for Russian (native), 'en' for English.",
                        "default": "ru"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Wildberries uses wbaas anti-bot protection. Residential proxy with Russian IP recommended for production runs. Datacenter may work for small tests but risks 498 blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
