# Eventbrite Email Scraper (`scrapapi/eventbrite-email-scraper`) Actor

- **URL**: https://apify.com/scrapapi/eventbrite-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, NaN 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

### **Eventbrite** Email Scraper 📱

**Eventbrite** Email Scraper allows you to **extract** a wide range of **data** from **Eventbrite** events, providing you with valuable insights for your marketing and outreach efforts. This tool is capable of gathering attendee email addresses, names, and other **contact** details from public events.

You can also **extract** event-specific information such as event titles, dates, and locations, enabling you to build comprehensive **data**sets. The **extract**ed **data** is organized and ready for integration into your CRM or email marketing software.

With its ability to scrape **Eventbrite** attendee **data** efficiently, this tool is perfect for lead generation, email list building, and event analysis. By automating the **data** collection process, you can save time and focus on utilizing the information for your business needs.

Eventbrite Email Scraper is a powerful tool designed to help you extract attendee email addresses and other relevant data from Eventbrite events effortlessly. This software simplifies the process of gathering contact information for event attendees, saving you time and effort.

With the Eventbrite Email Scraper, you can automate the tedious task of manually collecting attendee details. It is an ideal solution for marketers, event organizers, and businesses looking to build targeted email lists.

This Eventbrite data extraction tool ensures accurate and reliable data collection, enabling you to focus on leveraging the insights for your campaigns. It provides a seamless way to gather attendee information from public Eventbrite events.

### 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 |
| --- | --- |
| Attendee Emails | Extract email addresses of attendees from public Eventbrite events. |
| Attendee Names | Gather the names of event attendees for personalized outreach. |
| Event Titles | Retrieve the titles of events for better organization and analysis. |
| Event Dates | Extract the dates of events to plan your campaigns effectively. |
| Event Locations | Collect location details of events for targeted marketing. |
| Organizer Information | Scrape details about event organizers for networking purposes. |
| Event Descriptions | Capture event descriptions to understand the context and audience. |
| Ticket Pricing | Retrieve ticket pricing information for market analysis. |

### Key Features of **Eventbrite** Email Scraper

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

- ⭐ Automates the process of extracting attendee emails and other data from **Eventbrite** events
- ⭐ Supports scraping data from public **Eventbrite** events with high accuracy
- ⭐ Provides organized and structured data for easy integration into other tools
- ⭐ User-friendly interface suitable for both technical and non-technical users
- ⭐ **Customizable** scraping options to target specific data fields as needed
- ⭐ **Fast** and efficient data extraction saving time and resources
- ⭐ Compatible with various CRM and email marketing platforms for seamless data transfer
- ⭐ Includes advanced filtering options to refine your data collection
- ⭐ Ensures compliance with legal and ethical guidelines for data scraping
- ⭐ Offers scalable solutions for handling large volumes of **Eventbrite** data

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

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

1. ✅ **Sign up** for the **Eventbrite** Email Scraper tool and **log in**to your account
2. ✅ Enter the URL of the **Eventbrite** event you wish to scrape data from
3. ✅ **Select** the specific data fields you want to extract such as emails or attendee names
4. ✅ **Configure** any filters or customization options to refine your data collection
5. ✅ **Start** the scraping process and allow the tool to gather the requested data
6. ✅ Download the extracted data in your preferred format such as CSV or Excel
7. ✅ Import the data into your CRM or email marketing software for further use
8. ✅ Repeat the process for additional **Eventbrite** events as needed

### Use Cases 🎯

Lead Generation
🎯 Extract attendee emails to build targeted email lists for marketing campaigns
🎯 **Collect** contact information for potential clients or collaborators

Event Analysis
🎯 Gather event-specific data to analyze trends and audience demographics
🎯 **Use** attendee information to improve future event planning

Networking Opportunities
🎯 Scrape organizer details to connect with event hosts and industry leaders
🎯 **Identify** key attendees for professional outreach and collaboration

Market Research
🎯 Extract ticket pricing and event descriptions to study market trends
🎯 **Analyze** competitor events for strategic planning

### Why choose us? 💎

Our **Eventbrite** Email Scraper stands out for its accuracy, efficiency, and **user-friendly** design. It is built to cater to the needs of marketers, event organizers, and businesses looking to streamline their data collection processes.

With this tool, you can extract valuable attendee information from public **Eventbrite** events quickly and effortlessly. We prioritize data accuracy and organization, ensuring that the extracted data is ready for immediate use.

Our software is compatible with various platforms, making it easy to integrate with your existing tools. Additionally, we provide excellent customer support to assist you with any queries or issues.

By choosing our **Eventbrite** email automation tool, you gain access to a **reliable** and **scalable** solution for your data extraction needs. Whether you are building email lists, conducting market research, or analyzing event data, our tool is designed to help you achieve your goals efficiently.

### **Eventbrite** Email Scraper Scalability 📈

**Eventbrite** Email Scraper is designed to handle data extraction tasks of all sizes, making it a scalable solution for businesses and individuals alike. Whether you need to scrape data from a single event or multiple events, this tool can **efficient**ly manage the workload.

It is capable of processing large volumes of data without compromising on accuracy or speed. Our software is optimized for performance, ensuring that you can extract data quickly even when dealing with **extensive** datasets.

By offering **customizable** options and **advanced** filtering, it allows you to focus on the specific data you need. This scalability makes it an ideal choice for growing businesses and **large-scale** marketing campaigns.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Eventbrite**s terms of service when using the scraper
⚖️ **Only** scrape data from public **Eventbrite** events to avoid privacy violations
⚖️ **Do not** use the tool to collect sensitive or personal information without consent
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ **Avoid** sharing or selling the extracted data to third parties without permission
⚖️ Follow all applicable data protection and privacy laws in your region
⚖️ Regularly review **Eventbrite**s policies to stay updated on any changes
⚖️ Respect the rights and privacy of event organizers and attendees

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Eventbrite Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Eventbrite",
  "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 (Eventbrite) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Eventbrite",
    "keyword": "Eventbrite 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 Eventbrite as the source |
| keyword | Keyword that triggered the result (Eventbrite Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Eventbrite profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Eventbrite **Email Scraper**?

Eventbrite Email Scraper is a tool designed to extract attendee **emails** and other data from public Eventbrite events.

#### Is it **legal** to scrape data from Eventbrite?

**Yes**, as long as you comply with Eventbrite's terms of service and only scrape data from public events.

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

You can extract attendee **emails**, names, event details, organizer information, and more.

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

You can use the data for lead generation, marketing campaigns, event analysis, and networking.

#### Is the tool easy to use for non-technical users?

**Yes**, the tool is designed to be **user-friendly** and accessible for users of all skill levels.

#### Can I scrape data from multiple events at once?

**Yes**, the tool supports scraping data from multiple events efficiently.

#### What formats are available for downloading the data?

You can download the data in formats such as **CSV** or Excel for easy integration.

#### Is **customer support** available?

**Yes**, we provide excellent customer support to assist you with any issues or queries.

#### Does the tool comply with data protection laws?

**Yes**, the tool is designed to comply with data protection and privacy laws when used responsibly.

#### Can I customize the data fields to be **extract**ed?

**Yes**, you can select specific data fields to extract based on your requirements.

#### Is the tool scalable for large data **extract**ion tasks?

**Yes**, the tool is scalable and can handle **large volumes** of data efficiently.

#### What are the **limit**ations of using this tool?

The tool can only scrape data from public events and must comply with Eventbrite's terms of service.

#### How accurate is the **extract**ed data?

The tool is designed to provide highly accurate and reliable data extraction results.

#### Can I use the tool for competitor analysis?

**Yes**, you can use the tool to analyze competitor events and gather market insights.

#### Is there a free trial available?

Please check our website for details on free trials and pricing options.

# Actor input Schema

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

Add the topics, roles, or niches you care about (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Eventbrite profiles/posts that match these keywords and then extract email addresses from them. The more specific your keywords, the more targeted your leads. 🎯

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

Choose the platform you want to scrape data from. Currently, this actor is optimized for Eventbrite events and profiles. ✅

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

Optional: Narrow your search by adding a city, region, or country (e.g., 'London', 'New York'). Leave this empty to search globally and discover leads worldwide. 🌎

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

Optional: Keep your results focused by only collecting emails from specific domains (e.g., \['@gmail.com', '@outlook.com', '@company.com']). Leave this empty if you want to collect every email we can find. 🧲

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

Control how many emails you want per keyword (default: 20). Increase this if you want a bigger list, or lower it to just get a small, focused sample. 📈

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

Pick how you want the scraping to run.

🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping (best for most users).
🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors – more battle-tested but slower and more expensive.

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

Decide how protected and robust your scraping should be. By default, no proxy is used. If Google starts rejecting or blocking requests, the actor will automatically fall back to datacenter proxy, and then to residential proxy with up to 3 retries to keep your run stable. 🔁

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Eventbrite",
  "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/eventbrite-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/eventbrite-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/eventbrite-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Email Scraper",
        "version": "0.1",
        "x-build-id": "DOkTqPOihbucqYEHP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~eventbrite-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-eventbrite-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~eventbrite-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-eventbrite-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~eventbrite-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-eventbrite-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": "Add the topics, roles, or niches you care about (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Eventbrite profiles/posts that match these keywords and then extract email addresses from them. The more specific your keywords, the more targeted your leads. 🎯",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform 🌐",
                        "enum": [
                            "Eventbrite"
                        ],
                        "type": "string",
                        "description": "Choose the platform you want to scrape data from. Currently, this actor is optimized for Eventbrite events and profiles. ✅",
                        "default": "Eventbrite"
                    },
                    "location": {
                        "title": "Location Filter 📍",
                        "type": "string",
                        "description": "Optional: Narrow your search by adding a city, region, or country (e.g., 'London', 'New York'). Leave this empty to search globally and discover leads worldwide. 🌎",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter ✉️",
                        "type": "array",
                        "description": "Optional: Keep your results focused by only collecting emails from specific domains (e.g., ['@gmail.com', '@outlook.com', '@company.com']). Leave this empty if you want to collect every email we can find. 🧲",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword #️⃣",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Control how many emails you want per keyword (default: 20). Increase this if you want a bigger list, or lower it to just get a small, focused sample. 📈",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine ⚙️",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Pick how you want the scraping to run.\n\n🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping (best for most users).\n🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors – more battle-tested but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration 🛡️",
                        "type": "object",
                        "description": "Decide how protected and robust your scraping should be. By default, no proxy is used. If Google starts rejecting or blocking requests, the actor will automatically fall back to datacenter proxy, and then to residential proxy with up to 3 retries to keep your run stable. 🔁"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```