# VK Posts Scraper (`khadinakbar/vk-posts-scraper`) Actor

Scrape public VK wall posts and token-backed keyword search. Use for social monitoring, CIS research, and OSINT. Not for VK profiles, videos, member lists, or private content. Returns one record per post with text, author, engagement, media, URL. $0.005/post + $0.00005 start.

- **URL**: https://apify.com/khadinakbar/vk-posts-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 post scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## VK Posts Scraper

Scrape public posts from **VK (VKontakte)** community walls, user walls, and token-backed keyword search. Give it a handle, a profile/community URL, an owner id, or a single-post URL, and get back one clean JSON record per post: text, author, date, likes, reposts, comments, views, attachments, and the canonical post URL. Built MCP-ready for AI agents and automation pipelines.

### What you can do with it

- **Social-media monitoring** — track what a brand, community, or public figure posts on VK.
- **Market & audience research** — measure engagement (likes/reposts/comments/views) across CIS communities.
- **OSINT & investigation** — pull a public wall's history into structured data.
- **Content & trend analysis** — feed VK posts into dashboards, LLMs, or a data warehouse.

### When to use this actor

Use it when you need **posts from a public VK wall or a VK keyword search** as structured rows. It is **not** for VK videos, profiles, member lists, private content, or login-only pages — those are separate jobs. For a single post or keyword search, pass a VK access token.

### Output

One record per post:

| Field | Description |
|---|---|
| `postId`, `ownerId` | VK identifiers (`ownerId` is negative for communities) |
| `postUrl` | Canonical link, e.g. `https://vk.com/wall-1_123456` |
| `type` | `post` or `repost` |
| `isPinned` | Whether the post is pinned to the wall |
| `text` | Post body text |
| `date` | ISO 8601 timestamp (e.g. `2024-01-15T09:30:00.000Z`) |
| `timestamp` | Unix seconds |
| `authorName`, `authorScreenName`, `authorUrl`, `authorId`, `authorType` | Author identity (user or community) |
| `likes`, `reposts`, `comments`, `views` | Engagement counts |
| `attachments` | Array of `{ type, url, title? }` — photos, videos, links, docs, audio, polls |
| `repostOf` | The original post when `type` is `repost` |
| `source` | The input target this post came from |

#### Example record

```json
{
  "postId": 456239017,
  "ownerId": 1,
  "postUrl": "https://vk.com/wall1_456239017",
  "type": "post",
  "isPinned": false,
  "text": "Hello world",
  "date": "2024-01-15T09:30:00.000Z",
  "timestamp": 1705311000,
  "authorName": "Pavel Durov",
  "authorScreenName": "durov",
  "authorUrl": "https://vk.com/durov",
  "authorType": "user",
  "likes": 48213,
  "reposts": 1207,
  "comments": 9032,
  "views": 2841992,
  "attachments": [{ "type": "photo", "url": "https://sun9-...userapi.com/..." }],
  "repostOf": null,
  "source": "durov"
}
````

### Pricing

**Pay per event + usage:** at the default 2 GB memory, **$0.005 per post** + a $0.00005 actor-start fee. A 50-post run has at most **$0.25** in post event charges at the default memory. The `maxPosts` cap is a hard post-event ceiling, and skipped targets are never billed as posts. Apify compute and proxy usage are passed through separately. If you override run memory, Apify scales event counts by allocated GB.

### Input

| Field | Required | Description |
|---|---|---|
| `targets` | one of these | List of handles, URLs, owner ids, or post URLs (auto-detected) |
| `searchQuery` | one of these | Keyword search across VK posts (requires `vkAccessToken`) |
| `maxPosts` | no | Total cap across all targets (default 100, runtime max 1000) |
| `maxPostsPerTarget` | no | Per-wall cap (default 50, runtime max 500) |
| `vkAccessToken` | no | Optional VK API token to unlock the official-API path + keyword search |
| `proxyCountry` | no | Residential proxy country (default `RU`) |

#### Minimal input

```json
{ "targets": ["durov"], "maxPosts": 50 }
```

#### With a VK token (richer data + keyword search)

```json
{
  "searchQuery": "machine learning",
  "vkAccessToken": "<your VK service token>",
  "maxPosts": 100
}
```

### How it works — two paths

1. **Tokenless (default).** VK is a JavaScript-only single-page app, so the actor renders public walls in **Camoufox** (an anti-detect Firefox) over Apify **Residential** proxy in a CIS country, then parses the rendered posts. No login, no token.
2. **Token (recommended for reliability & exact data).** If you supply a free VK **service access token** (create one at a VK app dashboard on dev.vk.com), the actor uses the official VK API (`wall.get`, `wall.getById`, `newsfeed.search`) for **exact** engagement counts, exact ISO dates, comment/view counts, deeper pagination, single-post mode, and keyword search.

The output schema is identical for both paths, so you can start tokenless and add a token later without changing your pipeline.

### Reliability — please read

VK runs aggressive anti-bot protection (a JS redirect/login challenge tied to IP reputation). This has real consequences for the **tokenless** mode:

- It works best for **low-volume, occasional** scraping of **public** communities and user walls.
- Under heavy or repeated use, VK may flag the proxy pool and serve its login challenge. If at least one post was collected, the run finishes as `PARTIAL` with skipped targets recorded. If every usable route is blocked and zero posts are collected, the run honestly fails as `UPSTREAM_FAILED`.
- Some walls (e.g. certain news organisations) require a login even in a real browser; these are reported as skipped, not scraped.
- Tokenless mode returns text, author, likes, reposts, media, and post URLs reliably; **exact dates, comment counts, and view counts are not always available** without a token.

**For dependable, high-volume, exact-field scraping, use a VK access token** — the API path is deterministic and not subject to the browser challenge. A free service token takes a few minutes to create.

Other safeguards (both paths):

- Residential CIS proxy by default — VK throttles datacenter and non-CIS IPs.
- Session rotation + exponential backoff on `403`/`429`/`5xx`.
- Targets that are private, closed, deleted, blocked, or challenged are reported in the `skipped` summary rather than crashing the run.
- **Cost cap:** the actor prints the maximum post-event cost up front, validates each row before writing, charges only after a row is persisted, never charges past `maxPosts`, and never charges for skipped targets.

### Run summary

Every run writes:

- `OUTPUT` — compact terminal outcome (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`), item counts, charge counts, warnings, and dataset ID.
- `RUN_SUMMARY` — detailed diagnostics with route attempts, skipped targets, validation errors, cost-cap state, storage IDs, and billing counters.

### MCP / AI agents

This actor is designed to be called as a tool by Claude, ChatGPT, and other MCP clients via `mcp.apify.com`. Input is a small set of named fields; output is flat, stable JSON capped per run. Errors return actionable text (what to change, with an example).

### Use for AI agents

> Scrape posts from a VK (VKontakte) community or user wall, or run a VK keyword search. Returns one record per post with text, author, date, likes, reposts, views, comments, attachments, and post URL. Use for social monitoring, CIS-audience research, and OSINT. Not for VK videos, profiles, or member lists.

### Legal

Use this actor only for data that is publicly accessible and in compliance with VK's Terms of Service, applicable laws, and data-protection regulations (including GDPR where relevant). You are responsible for how you collect and use the data. Do not use it to scrape private content or to harass, profile, or harm individuals. This actor does not bypass authentication and does not access login-gated content.

# Actor input Schema

## `targets` (type: `array`):

VK walls or posts to scrape. Accepts handles, URLs, owner IDs, or wall post URLs such as 'durov', 'https://vk.com/team', '-22822305', or 'https://vk.com/wall-1\_123456'. Defaults to \['durov'] when no input is supplied. NOT a keyword search field; use searchQuery for token-backed keyword search.

## `searchQuery` (type: `string`):

Free-text keyword to search across public VK posts. Example: 'machine learning'. Defaults to blank and is ignored unless vkAccessToken is supplied, because VK newsfeed search is token-only. NOT a VK wall URL or handle.

## `maxPosts` (type: `integer`):

Hard cap on total posts returned across all targets and search. Example: 50 returns at most 50 billable post rows. Defaults to 100 and the runtime clamps the value to 1-1000. NOT a page count; one returned VK post equals one billable event.

## `maxPostsPerTarget` (type: `integer`):

Cap on posts taken from each individual VK wall before moving to the next target. Example: 25 spreads a 100-post budget over several communities. Defaults to 50 and is clamped to maxPosts and 500. NOT a global run cap; use maxPosts for that.

## `vkAccessToken` (type: `string`):

Optional VK API service or user access token. Example: a service token created in the VK app dashboard at dev.vk.com. Defaults to blank, which uses tokenless public-wall scraping and disables keyword search. NOT your VK password, login cookie, or private account session.

## `proxyCountry` (type: `string`):

Residential proxy country code used to reach VK. Example: 'RU'. Defaults to RU because VK commonly throttles datacenter and non-CIS IPs. NOT a content-language filter; it only controls the outbound proxy region.

## `saveHtmlSnapshot` (type: `boolean`):

Saves rendered VK wall HTML to the key-value store for selector troubleshooting. Example: true writes DEBUG\_DOM\_<slug> records. Defaults to false for normal runs. NOT needed for API-token runs or routine scraping.

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

Advanced Apify proxy override. Example: keep the default Residential proxy unless you know your target needs another group. Defaults to Apify Residential in proxyCountry. NOT required for normal runs; changing this can reduce VK reliability.

## Actor input object example

```json
{
  "targets": [
    "durov",
    "https://vk.com/team",
    "-22822305"
  ],
  "searchQuery": "machine learning",
  "maxPosts": 50,
  "maxPostsPerTarget": 25,
  "proxyCountry": "RU",
  "saveHtmlSnapshot": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `posts` (type: `string`):

Dataset items. One validated record per VK post returned.

## `output` (type: `string`):

Compact terminal outcome and counts for automation clients.

## `runSummary` (type: `string`):

Detailed route, validation, billing, and skipped-target diagnostics.

# 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 = {
    "targets": [
        "durov"
    ],
    "maxPosts": 50,
    "maxPostsPerTarget": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/vk-posts-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 = {
    "targets": ["durov"],
    "maxPosts": 50,
    "maxPostsPerTarget": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/vk-posts-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 '{
  "targets": [
    "durov"
  ],
  "maxPosts": 50,
  "maxPostsPerTarget": 25
}' |
apify call khadinakbar/vk-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VK Posts Scraper",
        "description": "Scrape public VK wall posts and token-backed keyword search. Use for social monitoring, CIS research, and OSINT. Not for VK profiles, videos, member lists, or private content. Returns one record per post with text, author, engagement, media, URL. $0.005/post + $0.00005 start.",
        "version": "1.0",
        "x-build-id": "ZKjyUd0IF02cORBIe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~vk-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-vk-posts-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/khadinakbar~vk-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-vk-posts-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/khadinakbar~vk-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-vk-posts-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": {
                    "targets": {
                        "title": "VK targets",
                        "type": "array",
                        "description": "VK walls or posts to scrape. Accepts handles, URLs, owner IDs, or wall post URLs such as 'durov', 'https://vk.com/team', '-22822305', or 'https://vk.com/wall-1_123456'. Defaults to ['durov'] when no input is supplied. NOT a keyword search field; use searchQuery for token-backed keyword search.",
                        "default": [
                            "durov"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query (token only)",
                        "type": "string",
                        "description": "Free-text keyword to search across public VK posts. Example: 'machine learning'. Defaults to blank and is ignored unless vkAccessToken is supplied, because VK newsfeed search is token-only. NOT a VK wall URL or handle.",
                        "default": ""
                    },
                    "maxPosts": {
                        "title": "Max posts (total)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on total posts returned across all targets and search. Example: 50 returns at most 50 billable post rows. Defaults to 100 and the runtime clamps the value to 1-1000. NOT a page count; one returned VK post equals one billable event.",
                        "default": 100
                    },
                    "maxPostsPerTarget": {
                        "title": "Max posts per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on posts taken from each individual VK wall before moving to the next target. Example: 25 spreads a 100-post budget over several communities. Defaults to 50 and is clamped to maxPosts and 500. NOT a global run cap; use maxPosts for that.",
                        "default": 50
                    },
                    "vkAccessToken": {
                        "title": "VK access token (optional)",
                        "type": "string",
                        "description": "Optional VK API service or user access token. Example: a service token created in the VK app dashboard at dev.vk.com. Defaults to blank, which uses tokenless public-wall scraping and disables keyword search. NOT your VK password, login cookie, or private account session."
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "enum": [
                            "RU",
                            "BY",
                            "KZ",
                            "UA",
                            "UZ",
                            "DE",
                            "US"
                        ],
                        "type": "string",
                        "description": "Residential proxy country code used to reach VK. Example: 'RU'. Defaults to RU because VK commonly throttles datacenter and non-CIS IPs. NOT a content-language filter; it only controls the outbound proxy region.",
                        "default": "RU"
                    },
                    "saveHtmlSnapshot": {
                        "title": "Save HTML snapshot",
                        "type": "boolean",
                        "description": "Saves rendered VK wall HTML to the key-value store for selector troubleshooting. Example: true writes DEBUG_DOM_<slug> records. Defaults to false for normal runs. NOT needed for API-token runs or routine scraping.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Advanced Apify proxy override. Example: keep the default Residential proxy unless you know your target needs another group. Defaults to Apify Residential in proxyCountry. NOT required for normal runs; changing this can reduce VK reliability.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
