# Vk Email Scraper Fast Advanced And Cheapest (`scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 VK Email Scraper extracts emails from VK fast and accurately! Advanced filters + bulk results at the lowest cost. Perfect for B2B lead gen, outreach, and recruitment. Save time, boost sales. 📧

- **URL**: https://apify.com/scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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 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/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 Email Scraper - Fast, Advanced and Cheapest 📬

**Vk Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Vk based on the keywords and email-domain filters you choose. It helps you solve the common problem of spending hours hunting for contact emails manually—whether you’re doing **VK email scraper** lead research, building **VK contacts email finder** lists, or running **bulk VK email scraping** for outreach. Whether you’re a marketer, recruiter, or data enthusiast, this **VK Email Extractor** automates the process of finding relevant contact emails from publicly available data and getting them into a ready-to-use dataset at scale—saving you hours of manual work.

---

### Why choose Vk Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-based email discovery** | Use your own keywords to find relevant Vk profiles and extract emails |
| ✅ **Custom email domain filtering** | Focus results on domains you care about (for example `@gmail.com`) |
| ✅ **Optional location filter** | Narrow results by location to improve relevance for your **VK leads email scraper** use case |
| ✅ **Controls for cost and runtime** | Use `maxEmails` to stop after reaching your target number and manage scraping time |
| ✅ **Structured dataset output** | Returns consistent fields like `keyword`, `title`, `url`, and `email` for easy analysis |
| ✅ **Resumable progress** | Keeps track of progress so long runs can continue without starting over |

---

### Key features

- 🔍 **Targeted VK email data extraction**: Finds and extracts email addresses from Vk using your provided keywords  
- 🧩 **Custom email-domain filters**: Uses your `customDomains` to keep results relevant to your target audience (e.g., Gmail vs. other domains)  
- 📍 **Location-aware results**: Adds a `location` filter when you need region-specific leads for your **VK group email scraper** workflows  
- 🎯 **Max-email stopping control**: Stops when `maxEmails` is reached, helping you control runtime and budget for **fast VK email scraper** runs  
- 🛡️ **Resilience for long batches**: Includes built-in handling for empty-result stretches and blocked pages so runs can finish more reliably  
- 💾 **Incremental dataset saving**: Pushes each found record to the dataset as it goes, so you don’t lose progress mid-run  
- 🔄 **Resume support**: Saves progress so you can continue later without re-collecting the same emails  

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "Berlin",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords (queries) used to find relevant Vk leads and extract matching emails from Vk |
| `location` | ❌ No | Location to filter the search results (leave empty for no location filtering) |
| `customDomains` | ❌ No | A list of email domains to target (example: `@gmail.com`, `@yahoo.com`) so you only collect emails that match your domain preferences |
| `maxEmails` | ❌ No | Maximum number of emails to collect. The scraper stops once this limit is reached. Higher values can take longer and don’t guarantee you’ll hit the exact number |

***

### Output

The actor saves each lead’s data in the **Vk Emails Dataset** dataset as JSON records.

A single pushed record has this shape:

```json
{
  "network": "Vk.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | Always set to `Vk.com` in the output |
| `keyword` | string | The keyword used for the current run context |
| `title` | string | Title text extracted from the result item (or `No title` if missing) |
| `description` | string | Description/details text extracted from the result item (or `No data` / `No data`-style fallback) |
| `url` | string | The result URL associated with the extracted email (or `No URL` if missing) |
| `email` | string | The extracted email address that matched your domain filters |

You can export the dataset from Apify Console to formats like JSON (and typically CSV via dataset export options on the platform).

***

### How to use Vk Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the Actors page.

2. **Find the actor**\
   Search for **Vk Email Scraper - Fast, Advanced and Cheapest** and open the actor details.

3. **Go to the INPUT section**\
   Use the built-in input form or paste an `input.json` payload matching the schema.

4. **Set your search keywords**\
   Fill in `keywords` with job titles or lead-relevant terms (for example: `manager`, `founder`). This is essential for **VK user email search** and **VK profile email scraper** use cases.

5. **Filter by email domains (recommended)**\
   Add `customDomains` like `@gmail.com` and `@yahoo.com` to improve relevance—especially helpful for **VK messaging email extraction tool** workflows.

6. **Optional: add a location filter**\
   Set `location` if you want to focus on a specific region; leave it blank for broader coverage.

7. **Set `maxEmails` for runtime control**\
   Choose `maxEmails` to cap how many emails you want to collect. This helps keep runs predictable for **bulk VK email scraping**.

8. **Run and monitor logs, then export results**\
   Start the run. You’ll see live logs as the actor finds and pushes records incrementally to the dataset. After it finishes, open the output dataset to export your data (e.g., JSON/CSV depending on your export options).

No coding required—get accurate results in minutes with this **VK email scraper online** workflow.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for Vk email extraction**: Designed specifically for **Vk Email Scraper - Fast, Advanced and Cheapest** use cases like “VK group email scraper”, “VK profile email scraper”, and “VK leads email scraper”
- 🧠 **Domain-targeted results**: Uses your `customDomains` list to focus on the email extensions that matter most to your outreach strategy
- 🔄 **Run resilience & stopping logic**: Includes stopping conditions when consecutive pages yield no new emails and stops once `maxEmails` is reached
- 💾 **Incremental persistence**: Each discovered lead is pushed to the dataset as it’s found, reducing risk if a run is interrupted
- 🧾 **Resume-friendly runs**: Progress is saved so you can continue later instead of restarting a long scrape

***

### Best use cases

- 📈 **Lead generation for B2B outreach**: Find emails linked to Vk presence using **VK email harvesting software** workflows and domain filters to keep your list clean
- 🎓 **Research and competitive intel**: Build structured samples from Vk leads to analyze contact patterns and messaging segments
- 🧭 **Recruitment pipeline building**: Extract emails relevant to roles like `manager` and `founder` for faster sourcing (a classic **VK contacts email finder** job-to-be-done)
- 🗺️ **Regional lead campaigns**: Use `location` to generate region-specific outreach lists as a **fast VK email scraper** alternative for broad research
- ✉️ **Email marketing list growth**: Collect domain-matched contacts for targeted campaigns with **VK email data extraction** outputs ready for CRM import
- 🔧 **Data analysis and enrichment**: Join `keyword`, `title`, `url`, and `email` fields in downstream pipelines for scoring and segmentation

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of domains like `@gmail.com` (optional)
  - ✅ `maxEmails` as an integer between 1 and 10000 (optional)

- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping

- **Retry Mechanism**
  - ✅ Includes handling for empty-result stretches and blocked pages to improve completion reliability

- **Dataset Structure**
  - ✅ Dataset title: **Vk Emails Dataset**
  - ✅ Dataset view: **Scraped Leads**
  - ✅ Output fields include: `keyword`, `title`, `description`, `url`, `email` (plus `network`)

- **Rate Limits & Performance**
  - ⚠️ Larger searches (more keywords/domains or higher `maxEmails`) can take longer
  - ⏳ Default run timeout (on the platform) is described in the actor input description as **3600 seconds / 1 hour** (configurable via **Run Options**)

- **Limitations**
  - ⚠️ If no matching emails are found for your selected domains/keywords, you may collect fewer than `maxEmails`
  - ⚠️ Free users have a maximum of **100 emails** enforced by the actor logic (paid users are not restricted by this cap)

***

### FAQ

#### Does Vk Email Scraper - Fast, Advanced and Cheapest require coding or an API?

✅ No. You can run **Vk Email Scraper - Fast, Advanced and Cheapest** directly in Apify Console and provide input via the actor INPUT form or by pasting an `input.json` payload.

#### What data does it return—emails only, or more fields too?

It extracts email addresses and also saves additional context fields in the dataset, including `keyword`, `title`, `description`, and `url`, alongside the extracted `email`.

#### How do `customDomains` affect results?

`customDomains` is used as a filter so the actor only extracts emails that match the email domains you provide (for example `@gmail.com`, `@yahoo.com`). This is one of the easiest ways to improve relevance for **VK email scraper** lead lists.

#### Can the actor stop early if I only need a small number of leads?

✅ Yes. Use `maxEmails` to cap the total number of emails collected. The actor will stop once this limit is reached.

#### What happens if results are limited or I don’t reach my target?

❌ If results are limited, you likely need wider coverage. Try broader or additional keywords, adjust your `customDomains`, or add/remove the `location` filter to change the result set.

#### Is there a limit on the number of emails for free users?

✅ Yes. The actor enforces a free-tier maximum of **100 emails**. Paid users don’t have this limitation in the same way.

#### Can I resume a run if it’s interrupted?

✅ Yes. The actor saves progress and can resume using stored progress state so you don’t have to start from zero.

#### Is it legal to use this for lead generation?

✅ The actor collects information from **publicly available sources**. It’s still your responsibility to comply with applicable laws (including GDPR/CCPA where relevant), spam regulations, and the platform’s terms of service when using the data.

***

### Support & feature requests

If you’re using **Vk Email Scraper - Fast, Advanced and Cheapest** and want improvements, share your feedback and feature requests.

- 💡 **Feature Requests**: Ask for enhancements like additional export options, better filtering controls, or workflow improvements for **VK group email scraper** and **VK profile email scraper** use cases.
- 📧 **Contact**: For support or custom requests, email <dataforleads@gmail.com>.

User feedback helps shape the roadmap for this **VK Email Extractor**.

***

*The fastest way to get structured Vk contact emails—**Vk Email Scraper - Fast, Advanced and Cheapest** with a dataset you can use immediately.*

***

### Disclaimer

This tool **only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws and regulations (including GDPR/CCPA where relevant), spam rules, and platform terms of service when collecting or using email data. For data-removal requests, contact <dataforleads@gmail.com>.

Please use this **Vk Email Scraper - Fast, Advanced and Cheapest** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/vk-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vk Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 VK Email Scraper extracts emails from VK fast and accurately! Advanced filters + bulk results at the lowest cost. Perfect for B2B lead gen, outreach, and recruitment. Save time, boost sales. 📧",
        "version": "1.0",
        "x-build-id": "vZvJVfOhivpCr2pBE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~vk-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-vk-email-scraper-fast-advanced-and-cheapest",
                "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/scrapers-hub~vk-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-vk-email-scraper-fast-advanced-and-cheapest",
                "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/scrapers-hub~vk-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-vk-email-scraper-fast-advanced-and-cheapest",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
