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

- **URL**: https://apify.com/scrapapi/vimeo-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, 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.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 📱

The **Vimeo** Email Scraper allows users to **extract** a variety of **data** from **Vimeo** profiles. This includes essential **contact** information such as email addresses, which can be used for legitimate outreach purposes.

The tool is capable of scanning public profiles and retrieving available email **data**. Additionally, it can gather supplementary information such as profile names, user descriptions, and follower counts.

By using this **Vimeo** email **extract**ion software, you can ensure that your **data** collection is both accurate and efficient. The scraper is designed to comply with legal guidelines, ensuring ethical **data** harvesting practices.

It is an invaluable tool for businesses, marketers, and researchers seeking to connect with **Vimeo** users.

Vimeo Email Scraper is a powerful tool designed to help you extract emails from Vimeo profiles quickly and efficiently. It simplifies the process of gathering contact information from Vimeo users for legitimate purposes.

With Vimeo Email Scraper, you can automate the process of finding email addresses associated with Vimeo accounts. This tool is ideal for businesses, marketers, and researchers looking to connect with content creators on Vimeo.

The Vimeo Email Scraper is user-friendly and requires minimal technical expertise to operate. It is designed to save time and effort while ensuring accurate results.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Retrieve publicly available email addresses from Vimeo profiles. |
| Profile Names | Extract the names associated with Vimeo profiles. |
| User Descriptions | Capture user-provided descriptions from their Vimeo profiles. |
| Follower Counts | Collect information about the number of followers a user has. |
| Profile Links | Gather direct links to Vimeo profiles for further reference. |
| Video Links | Extract URLs of videos associated with the profiles. |
| Location Data | Retrieve location information if provided by the user on their profile. |
| Account Creation Date | Identify when the Vimeo account was created. |

### 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** email extraction from **Vimeo** profiles with high accuracy
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ Ability to extract multiple data types including emails profile names and follower counts
- ⭐ **Fast** and efficient scraping process to save time and effort
- ⭐ **Customizable** settings to target specific profiles or data points
- ⭐ Compliance with legal and ethical guidelines for data collection
- ⭐ Supports bulk scraping for large-scale data extraction projects
- ⭐ Detailed reporting and export options for easy data management
- ⭐ **Regular** updates to ensure compatibility with **Vimeo** platform changes
- ⭐ **Secure** and reliable software with robust data protection measures

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

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

1. ✅ Download and install the **Vimeo** Email Scraper software on your device
2. ✅ Log in to the tool using your credentials or create a new account if needed
3. ✅ Enter the URL of the **Vimeo** profile or search query you want to scrape
4. ✅ Customize the scraping settings to specify the data types you need
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraping task in the dashboard
7. ✅ Once completed review the extracted data in the results section
8. ✅ **Export** the data in your preferred format such as CSV or Excel
9. ✅ Use the extracted email addresses for legitimate outreach or research purposes
10. ✅ Repeat the process for additional profiles or queries as needed

### Use Cases 🎯

Marketing and Outreach
🎯 Build targeted email lists for marketing campaigns
🎯 Connect with **Vimeo** content creators for collaboration opportunities

Research and Analysis
🎯 Gather data for market research and trend analysis
🎯 **Analyze** **Vimeo** user demographics and engagement metrics

Business Development
🎯 **Identify** potential partners or clients on **Vimeo**
🎯 Reach out to content creators for business proposals

Content Curation
🎯 **Find** and contact creators for content licensing or partnerships
🎯 Build a database of creators for future collaborations

### Why choose us? 💎

Our **Vimeo** Email Scraper stands out as the **best** **Vimeo** email scraping tool due to its reliability and efficiency. It is designed to cater to the needs of businesses, marketers, and researchers who require accurate and ethical data collection.

The tool offers a **user-friendly** interface, making it accessible even to those with minimal technical expertise. With **advanced** features like customizable settings and bulk scraping, it ensures that you can extract the data you need quickly and effectively.

We prioritize compliance with legal and ethical guidelines, ensuring that all data collection practices are legitimate. Our software is **regular**ly updated to adapt to changes on the **Vimeo** platform, providing consistent performance.

By choosing our **Vimeo** Email Scraper, you gain access to a secure and **reliable** tool that saves time, enhances productivity, and delivers high-quality results.

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

The **Vimeo** Email Scraper is designed to handle projects of all sizes, making it an ideal solution for both small-scale and **large-scale** data extraction needs. Its robust architecture ensures that it can process multiple profiles simultaneously without compromising on performance.

Whether you need to extract data from a few profiles or thousands, the tool is capable of delivering accurate results **efficient**ly. With features like bulk scraping and **customizable** settings, it allows you to scale your operations as needed.

The software is optimized to handle high volumes of data while maintaining speed and reliability. This scalability makes it a valuable asset for businesses, marketers, and researchers looking to expand their outreach or analysis efforts.

### **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** that you only scrape publicly available data from **Vimeo** profiles
⚖️ **Do not** use the tool for unauthorized or illegal purposes
⚖️ Respect **Vimeo**s terms of service and community guidelines while using the scraper
⚖️ **Obtain** consent from users before using their email addresses for outreach
⚖️ **Avoid** scraping sensitive or private information from **Vimeo** profiles
⚖️ **Use** the tool responsibly to maintain ethical data collection practices
⚖️ Comply with data protection regulations such as GDPR or CCPA where applicable
⚖️ **Do not** share or sell extracted data without proper authorization

### 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 the scraper easy to use?

**Yes**, the Vimeo Email Scraper features a **user-friendly** interface that requires minimal technical expertise.

#### What data can I **extract** with this tool?

You can extract email addresses, profile names, user descriptions, follower counts, and more.

#### Is the tool compliant with **legal** guidelines?

**Yes**, the Vimeo Email Scraper is designed to comply with data protection regulations and ethical guidelines.

#### Can I use the scraper for bulk data **extract**ion?

**Yes**, the tool supports bulk scraping for large-scale data extraction projects.

#### How do I **export** the **extract**ed data?

You can export the data in formats like **CSV** or Excel for easy management.

#### Does the scraper work on all Vimeo profiles?

The tool can only scrape **publicly available** data from Vimeo profiles.

#### Is the software regularly updated?

**Yes**, the Vimeo Email Scraper is updated regularly to ensure compatibility with Vimeo platform changes.

#### Can I customize the scraping settings?

**Yes**, the tool allows you to customize settings to target specific profiles or data types.

#### Is my data **secure** while using the scraper?

**Yes**, the software includes robust data protection measures to ensure your data remains **secure**.

#### Can I scrape **private** Vimeo profiles?

**No**, the tool is designed to only scrape data from publicly accessible profiles.

#### What are the system requirements for the scraper?

The tool is compatible with most modern operating systems and requires an active internet connection.

#### Do I need a Vimeo account to use the scraper?

**No**, you do not need a Vimeo account to use the tool, but it may enhance certain functionalities.

#### Can I use the tool for marketing purposes?

**Yes**, you can use the extracted data for legitimate marketing and outreach purposes.

#### What support options are available?

We offer customer support to assist with any issues or questions regarding the Vimeo Email Scraper.

# 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("scrapapi/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("scrapapi/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 scrapapi/vimeo-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vimeo Email Scraper",
        "version": "0.1",
        "x-build-id": "kv6dQgu4nOPsQ5LlA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~vimeo-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~vimeo-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~vimeo-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```