# RuStore App Scraper & Monitor (`sashaebashu/rustore-scraper`) Actor

Scrape apps from RuStore (Russia's Android app store): ratings, review counts, versions, sizes, prices, developers — and track what changes between runs.

- **URL**: https://apify.com/sashaebashu/rustore-scraper.md
- **Developed by:** [Sasha Ebashu](https://apify.com/sashaebashu) (community)
- **Categories:** E-commerce, Integrations, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## RuStore App Scraper & Monitor

Scrape apps from **RuStore** — Russia's Android app store (VK), preinstalled on every phone sold in the country — and track **what changes between runs**.

Ratings, review counts, downloads, versions, sizes, prices, developers. ~69,500 apps.

### What you get

One row per app:

| Field | Meaning |
|---|---|
| `packageName`, `name`, `url`, `description` | App identity |
| **`rating`**, **`ratingCount`** | Star rating and how many ratings it has |
| `downloads` | RuStore's own downloads bucket (`"40 млн +"`) — a rounded band, never an exact number |
| **`version`**, `fileSizeBytes`, **`updatedAt`** | Current version, APK size, when it was last updated |
| `price`, `priceCurrency`, `isFree` | Price in ₽ |
| `developer`, `developerId`, `developerUrl` | Publisher and their RuStore profile |
| `category`, `contentRating` | e.g. `SocialNetworkingApplication`, `12+` |
| `sourceCategory` | The RuStore category the app was discovered in (when using **Categories**) — e.g. `finance`, `games/free` |
| `verified` | RuStore's data-safety moderation badge |
| `icon`, `screenshots[]` | Media |
| `reviews[]` | Optional — the handful of reviews RuStore embeds in the app card (author, rating, date, text) |

In **Monitor mode** every row also gets `changeType` — `new` / **`rating_up`** / **`rating_down`** / `reviews_change` / **`version_change`** / `price_up` / `price_down` / **`delisted`** / `relisted` / `unchanged` — plus `previousRating`, `previousRatingCount`, `previousVersion`, `previousPrice`, `firstSeenAt`, `lastConfirmedAt` and a 30-day rating band.

**Delisted apps are reported, not dropped.** If an app is pulled from RuStore (its page starts returning 404) you still get a row — `delisted: true`, `changeType: "delisted"` — carrying its last known name and rating. An app leaving the store is a signal, not missing data. It is reported once, then stays `unchanged` until it returns (`relisted`).

### Reviews mode

Turn on **Reviews mode** and the output becomes **one row per review** — `appName`, `packageName`, `author`, `rating`, `datePublished`, `text`, plus the app's `appRating` / `totalReviews` for context.

**The honest limit:** RuStore renders exactly the **30 most recent reviews** per app and offers no way to get more — no pagination, no "show more", and scrolling loads nothing. So:

| App | What 30 reviews covers |
|---|---|
| Yandex Cloud (19 reviews total) | **its complete history** — 2023 → 2026 |
| Толока (57 total) | the last **1.5 years** |
| 2ГИС (7,571 total) | the last **4 days** |
| ВКонтакте (34,800 total) | the last **~15 minutes** |

For most of the catalogue's long tail, 30 is everything there is. For busy apps it is a rolling window — so **run Reviews mode with Monitor mode on a schedule**: each run emits only reviews it has not seen before, and the dataset accumulates the review stream. (Verified: a second run 60 seconds later returned exactly 1 row — the single new review that had appeared.)

### Use it for

- **Review mining** — collect reviews per app on a schedule (see Reviews mode).
- **ASO / competitor tracking** — watch a rival's rating, review count and release cadence (`updatedAt` + `version_change`).
- **Market research** — pull a whole RuStore category (`finance`, `games`…) and compare ratings, prices and publishers side by side.
- **Release monitoring** — get notified when an app ships a new version, changes price, or disappears.

### Input

| Option | Description |
|---|---|
| **Apps** | Package names (`com.vkontakte.android`) or full RuStore URLs — both accepted. |
| **Categories** | Scrape whole RuStore categories — `finance`, `games`, `health`… Accepts a slug, a slug with a price filter (`finance/free`, `tools/paid` — every category except `games` and `tv`), or a full category URL including topic pages like `/catalog/all/tag-anime-5`. Every row is tagged with `sourceCategory`. |
| **Crawl the catalogue** | Pull apps from RuStore's own sitemap (~69,500 apps). |
| **Catalogue filter** | Only apps whose package contains this text — `yandex`, `sberbank`, `com.vk`. |
| **Max apps from catalogue** / **Max apps** | Keep a run bounded. |
| **Include reviews** | Add the handful of reviews embedded in each app card (app mode). |
| **Reviews mode** | Output one row per review instead of per app — 30 most recent per app. With Monitor mode, only reviews not seen before. |
| **Monitor mode** / **Only output changes** | Compare against the previous run; optionally emit only what moved. |
| **Max concurrency** | Parallel page fetches (default 10). |
| **Proxy** | Apify datacenter proxy (the default) — cheap, no residential needed. |

#### Example

```json
{
  "crawlSitemap": true,
  "appFilter": "yandex",
  "maxAppsFromSitemap": 100,
  "monitorMode": true,
  "onlyChanges": true
}
````

Schedule that and each run's dataset is a clean list of every Yandex app whose rating, version or price moved.

### Notes & limits

- **A proxy is required.** RuStore's antibot (`kittenx`) challenges some networks — a plain unproxied request can get bounced to a challenge page. The Apify **datacenter** proxy sails through and is the cheapest option; it is the default.
- **`downloads` is a bucket, not a count.** RuStore only ever publishes rounded bands (`"40 млн +"`). It is reported verbatim rather than turned into a fake precise number.
- **Unrated apps return `rating: null`** — that is real (nobody has rated them), not a scrape failure.
- **Reviews are capped at the 30 most recent per app** — that is RuStore's limit, not the Actor's. There is no pagination to work around it. Apps with ≤30 reviews yield their full history.
- **RuStore's antibot throttles in waves.** When it does, some app pages cannot be fetched even after 9 retries. The run never hides this: it warns with the exact count and percentage, names the affected packages, and stores the full list in the run's key-value store under **`FAILED_APPS`** — so you can re-run just those later.
- **If you see losses, LOWER "Max concurrency", don't raise it.** Measured: concurrency 30 was only ~13% faster than 15 but lost 33 apps instead of 1. The default of 10 is the sweet spot; heavy parallelism makes the antibot throttle harder.
- Runs stop cleanly before the platform timeout and honour the run's maximum-cost limit, committing what they have.

# Actor input Schema

## `packageNames` (type: `array`):

Apps to scrape — either bare package names (com.vkontakte.android) or full RuStore URLs (https://www.rustore.ru/catalog/app/com.vkontakte.android). Both forms are accepted.

## `crawlSitemap` (type: `boolean`):

Instead of listing apps, pull them from RuStore's own app sitemap (~69,500 apps). Narrow it with the filter below and cap it with 'Max apps from catalogue'. Off by default.

## `categories` (type: `array`):

Scrape every app RuStore lists in these categories. Accepts a slug (finance, games, health, education, social, tools, books, sport, news, travelling, pets, parenting, business, transport, purchases, entertainment, foodanddrink, lifestyle, state, adsandservices, gambling, tv, all), a slug with a price filter (finance/free, tools/paid — available for every category except games and tv), or a full category URL, including RuStore's narrower topic pages such as https://www.rustore.ru/catalog/all/tag-anime-5. Each app row is tagged with the category it came from (sourceCategory). Unknown categories are skipped with a warning.

## `appFilter` (type: `string`):

Only crawl apps whose package name contains this text — e.g. "sberbank", "yandex", "com.vk". Leave empty to take the catalogue in order.

## `maxAppsFromSitemap` (type: `integer`):

Cap on how many app pages the catalogue crawl fetches. Keeps a catalogue-wide run bounded.

## `includeReviews` (type: `boolean`):

Add the reviews RuStore embeds in the app page (author, rating, date, text). These are the most recent few, not the full review history.

## `reviewsMode` (type: `boolean`):

Output REVIEWS instead of apps: one row per review (app, author, rating, date, text). RuStore exposes only the 30 most recent reviews per app and offers no pagination — so for an app with <=30 reviews that is its complete history, while for a busy app it is a rolling window (e.g. VK's 30 = the last ~15 minutes). With Monitor mode on, only reviews not seen in a previous run are emitted, so scheduling this accumulates the review stream.

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

Stop after this many dataset rows. In app mode a row is an app; in Reviews mode a row is a review (one app yields up to 30). 0 = no limit.

## `maxConcurrency` (type: `integer`):

How many app pages to fetch in parallel.

## `monitorMode` (type: `boolean`):

Compare this run against the previous one and label every app: new / rating\_up / rating\_down / reviews\_change / version\_change / price\_up / price\_down / delisted / relisted / unchanged. Also adds previous\* values, first-seen/last-confirmed stamps and a 30-day rating band. Off by default.

## `onlyChanges` (type: `boolean`):

With Monitor mode on, skip apps that did not change — the dataset then contains only what actually moved.

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

RuStore's antibot challenges some networks, so a proxy is required. The default Apify datacenter proxy works and is the cheapest option.

## Actor input object example

```json
{
  "packageNames": [
    "com.vkontakte.android"
  ],
  "crawlSitemap": false,
  "categories": [
    "finance",
    "finance/free"
  ],
  "appFilter": "yandex",
  "maxAppsFromSitemap": 200,
  "includeReviews": false,
  "reviewsMode": false,
  "maxItems": 0,
  "maxConcurrency": 10,
  "monitorMode": false,
  "onlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Every app with its rating, version, size and price.

## `changes` (type: `string`):

What moved since the previous run (monitor mode).

## `reviews` (type: `string`):

One row per review (reviews mode).

# 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 = {
    "packageNames": [
        "com.vkontakte.android",
        "ru.dublgis.dgismobile"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sashaebashu/rustore-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 = { "packageNames": [
        "com.vkontakte.android",
        "ru.dublgis.dgismobile",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sashaebashu/rustore-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 '{
  "packageNames": [
    "com.vkontakte.android",
    "ru.dublgis.dgismobile"
  ]
}' |
apify call sashaebashu/rustore-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RuStore App Scraper & Monitor",
        "description": "Scrape apps from RuStore (Russia's Android app store): ratings, review counts, versions, sizes, prices, developers — and track what changes between runs.",
        "version": "0.1",
        "x-build-id": "nICVOUclFIMRLs81n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sashaebashu~rustore-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sashaebashu-rustore-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/sashaebashu~rustore-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sashaebashu-rustore-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/sashaebashu~rustore-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sashaebashu-rustore-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": {
                    "packageNames": {
                        "title": "Apps (package names or URLs)",
                        "type": "array",
                        "description": "Apps to scrape — either bare package names (com.vkontakte.android) or full RuStore URLs (https://www.rustore.ru/catalog/app/com.vkontakte.android). Both forms are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "crawlSitemap": {
                        "title": "Crawl the catalogue",
                        "type": "boolean",
                        "description": "Instead of listing apps, pull them from RuStore's own app sitemap (~69,500 apps). Narrow it with the filter below and cap it with 'Max apps from catalogue'. Off by default.",
                        "default": false
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Scrape every app RuStore lists in these categories. Accepts a slug (finance, games, health, education, social, tools, books, sport, news, travelling, pets, parenting, business, transport, purchases, entertainment, foodanddrink, lifestyle, state, adsandservices, gambling, tv, all), a slug with a price filter (finance/free, tools/paid — available for every category except games and tv), or a full category URL, including RuStore's narrower topic pages such as https://www.rustore.ru/catalog/all/tag-anime-5. Each app row is tagged with the category it came from (sourceCategory). Unknown categories are skipped with a warning.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appFilter": {
                        "title": "Catalogue filter",
                        "type": "string",
                        "description": "Only crawl apps whose package name contains this text — e.g. \"sberbank\", \"yandex\", \"com.vk\". Leave empty to take the catalogue in order."
                    },
                    "maxAppsFromSitemap": {
                        "title": "Max apps from catalogue",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on how many app pages the catalogue crawl fetches. Keeps a catalogue-wide run bounded.",
                        "default": 200
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Add the reviews RuStore embeds in the app page (author, rating, date, text). These are the most recent few, not the full review history.",
                        "default": false
                    },
                    "reviewsMode": {
                        "title": "Reviews mode (one row per review)",
                        "type": "boolean",
                        "description": "Output REVIEWS instead of apps: one row per review (app, author, rating, date, text). RuStore exposes only the 30 most recent reviews per app and offers no pagination — so for an app with <=30 reviews that is its complete history, while for a busy app it is a rolling window (e.g. VK's 30 = the last ~15 minutes). With Monitor mode on, only reviews not seen in a previous run are emitted, so scheduling this accumulates the review stream.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many dataset rows. In app mode a row is an app; in Reviews mode a row is a review (one app yields up to 30). 0 = no limit.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many app pages to fetch in parallel.",
                        "default": 10
                    },
                    "monitorMode": {
                        "title": "Monitor mode (track changes)",
                        "type": "boolean",
                        "description": "Compare this run against the previous one and label every app: new / rating_up / rating_down / reviews_change / version_change / price_up / price_down / delisted / relisted / unchanged. Also adds previous* values, first-seen/last-confirmed stamps and a 30-day rating band. Off by default.",
                        "default": false
                    },
                    "onlyChanges": {
                        "title": "Only output changes",
                        "type": "boolean",
                        "description": "With Monitor mode on, skip apps that did not change — the dataset then contains only what actually moved.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "RuStore's antibot challenges some networks, so a proxy is required. The default Apify datacenter proxy works and is the cheapest option.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
