# Vimeo Email Scraper (`scraper-engine/vimeo-email-scraper`) Actor

Vimeo Email Scraper extracts publicly available email addresses from Vimeo profiles and video pages. Build targeted creator contact lists by category or region. Ideal for brands and agencies running creator outreach campaigns.

- **URL**: https://apify.com/scraper-engine/vimeo-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **Vimeo** Email Scraper 📱

**Vimeo** Email Scraper allows users to **extract** essential **contact** information from **Vimeo** profiles. This includes email addresses, which are crucial for marketing and networking purposes.

The tool is designed to identify publicly available **data** and organize it efficiently for further use. In addition to email addresses, users can gather profile names, video titles, and descriptions.

**Vimeo** Email Scraper ensures that the **extract**ed **data** is accurate and formatted for easy integration into your workflows. By automating the **data** **extract**ion process, it helps users save time and focus on their core tasks.

This tool is ideal for professionals who need reliable **contact** information from **Vimeo** profiles to support their projects or campaigns.

Vimeo Email Scraper is a powerful tool designed to help you extract contact information from Vimeo profiles efficiently. It simplifies the process of gathering email addresses for marketing, networking, or lead generation purposes.

Vimeo is a popular video-sharing platform where creators and businesses showcase their work. With Vimeo Email Scraper, you can streamline the process of collecting valuable data from these profiles.

Using Vimeo Email Scraper, businesses can save time and resources while building targeted email lists. It is ideal for professionals looking to connect with Vimeo users for collaboration or promotional activities.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Vimeo profiles for outreach purposes. |
| Profile names | Retrieve the names of Vimeo users to personalize communication. |
| Video titles | Collect titles of videos uploaded by users for content analysis. |
| Video descriptions | Extract video descriptions to understand the content focus of users. |
| Profile URLs | Gather direct links to Vimeo profiles for easy access. |
| User locations | Identify location details provided by users in their profiles. |
| Tags and categories | Extract tags and categories associated with videos for segmentation. |
| Follower count | Retrieve follower counts to evaluate user influence on Vimeo. |

### Key Features of **Vimeo** Email Scraper

Here are the **standout features** that make the **Vimeo** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of email addresses from **Vimeo** profiles for faster lead generation
- ⭐ Ability to gather additional profile data such as names descriptions and URLs for comprehensive insights
- ⭐ User-friendly interface designed for both technical and non-technical users
- ⭐ **Advanced** filtering options to target specific profiles or content types on **Vimeo**
- ⭐ **High** accuracy in identifying publicly available contact information from profiles
- ⭐ **Secure** data extraction process to protect user privacy and comply with regulations
- ⭐ **Integration** capabilities with CRM systems and email marketing tools for streamlined workflows
- ⭐ **Customizable** scraping settings to meet unique project requirements
- ⭐ Support for bulk data extraction to handle large-scale campaigns efficiently
- ⭐ **Regular** updates to ensure compatibility with **Vimeo**s platform changes

### How to use **Vimeo** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Vimeo** emails today:

1. ✅ Download and install **Vimeo** Email Scraper on your device
2. ✅ Log in to your **Vimeo** account to access profiles and videos
3. ✅ Enter the URL or keywords of the profiles or videos you want to scrape
4. ✅ **Configure** the scraping settings to specify the data types you wish to extract
5. ✅ **Start** the scraping process and monitor progress through the tools dashboard
6. ✅ **Review** the extracted data and verify its accuracy using the built-in validation feature
7. ✅ **Export** the data to your preferred format such as CSV or Excel for further use
8. ✅ **Integrate** the extracted data with your CRM or email marketing software

### Use Cases 🎯

Lead Generation
🎯 Build targeted email lists from **Vimeo** profiles for marketing campaigns
🎯 **Identify** potential collaborators or clients based on profile data

Content Analysis
🎯 Extract video titles and descriptions to analyze content trends
🎯 Segment users based on tags and categories for personalized outreach

Networking
🎯 Connect with **Vimeo** creators and businesses using extracted email addresses
🎯 **Identify** influential profiles for partnership opportunities

Market Research
🎯 Gather data on user locations and follower counts for demographic analysis
🎯 Understand user preferences through video descriptions and tags

### Why choose us? 💎

**Vimeo** Email Scraper stands out as the **best** **Vimeo** scraper tool due to its **advanced** features and **user-friendly** design. Our software is tailored to meet the needs of marketers, researchers, and businesses looking to extract emails from **Vimeo** profiles efficiently.

We prioritize accuracy and reliability, ensuring that the data collected is relevant and useful for your campaigns. With **Vimeo** Email Scraper, you can automate the data extraction process, saving time and resources while focusing on your core objectives.

Our tool integrates seamlessly with other software, making it easy to incorporate the extracted data into your workflows. We offer **regular** updates to keep the scraper compatible with **Vimeo**'s platform changes, ensuring uninterrupted service.

Choose **Vimeo** Email Scraper for a secure, **scalable**, and efficient solution to your email scraping needs.

### **Vimeo** Email Scraper Scalability 📈

**Vimeo** Email Scraper is designed to handle data extraction tasks of any scale, making it ideal for businesses of all sizes. Whether you need to scrape a few profiles or thousands, our tool ensures consistent performance and accuracy.

The software supports bulk data extraction, allowing you to gather information from multiple profiles simultaneously. Advanced filtering options enable users to target specific data types or categories, enhancing scalability for diverse projects.

**Vimeo** Email Scraper is equipped with robust infrastructure to manage **large-scale** campaigns without compromising speed or reliability. By automating the process, it reduces manual effort and ensures **efficient** handling of **extensive** data sets.

Rely on **Vimeo** Email Scraper for a scalable solution to your email scraping requirements.

### **Vimeo** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Vimeo** is **legal** as long as you follow **ethical** and **compliant** practices. The **Vimeo** Email Scraper extracts only **publicly available** information from **public** **Vimeo** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Vimeo**s terms of service while using the scraper
⚖️ **Only** extract publicly available data from profiles and videos
⚖️ **Do not** use the tool to collect sensitive or private information without consent
⚖️ **Avoid** scraping data for malicious or unethical purposes
⚖️ Respect user privacy and adhere to data protection regulations such as GDPR
⚖️ Consult legal professionals if unsure about the legality of your scraping activities
⚖️ **Use** the tool responsibly to maintain the integrity of **Vimeo**s platform
⚖️ Clearly disclose the purpose of data collection to stakeholders when applicable

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Vimeo Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Vimeo",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Vimeo) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Vimeo",
    "keyword": "Vimeo Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Vimeo as the source |
| keyword | Keyword that triggered the result (Vimeo Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Vimeo profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Vimeo **Email Scraper**?

Vimeo Email Scraper is a tool designed to extract email addresses and other data from Vimeo profiles efficiently.

#### Is Vimeo **Email Scraper** **legal** to use?

**Yes**, as long as you comply with Vimeo's terms of service and extract **publicly available** data responsibly.

#### What data can I **extract** using Vimeo **Email Scraper**?

You can extract email addresses, profile names, video titles, descriptions, URLs, locations, tags, and follower counts.

#### Can I use Vimeo **Email Scraper** for bulk data **extract**ion?

**Yes**, the tool supports bulk data extraction for handling large-scale campaigns.

#### Is the **extract**ed data accurate?

Vimeo Email Scraper prioritizes accuracy and reliability to ensure the data collected is relevant and useful.

#### Does Vimeo **Email Scraper** integrate with other software?

**Yes**, it integrates **seamless**ly with CRM systems and email marketing tools.

#### Is Vimeo **Email Scraper** easy to use?

**Yes**, it features a **user-friendly** interface suitable for both technical and non-technical users.

#### How often is Vimeo **Email Scraper** updated?

The tool is regularly updated to ensure compatibility with Vimeo's platform changes.

#### Can I customize the scraping settings?

**Yes**, you can configure the settings to target specific profiles or data types.

#### Is Vimeo **Email Scraper** **secure**?

**Yes**, the tool uses **secure** processes to protect user privacy and comply with regulations.

#### What formats can I **export** the data to?

You can export the data to formats like **CSV** or Excel for further use.

#### Does Vimeo **Email Scraper** require a Vimeo account?

**Yes**, you need to log in to your Vimeo account to access profiles and videos.

#### Can I scrape **private** profiles with Vimeo **Email Scraper**?

**No**, the tool only extracts **publicly available** data from profiles and videos.

#### What support is available for Vimeo **Email Scraper**?

We offer customer support to assist with any issues or questions regarding the tool.

#### Is Vimeo **Email Scraper** suitable for small businesses?

**Yes**, it is scalable and can be used by **businesses** of all sizes for efficient data extraction.

# Actor input Schema

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

List of keywords to search for on Vimeo (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Vimeo profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Vimeo",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/vimeo-email-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/vimeo-email-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/vimeo-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vimeo Email Scraper",
        "description": "Vimeo Email Scraper extracts publicly available email addresses from Vimeo profiles and video pages. Build targeted creator contact lists by category or region. Ideal for brands and agencies running creator outreach campaigns.",
        "version": "0.1",
        "x-build-id": "udwvR443KmuQWdLwY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~vimeo-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-vimeo-email-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/scraper-engine~vimeo-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-vimeo-email-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/scraper-engine~vimeo-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-vimeo-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Vimeo (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Vimeo profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Vimeo"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Vimeo"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```