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

⚡️ Extract targeted Eventbrite attendee & event data fast with the Fast Advanced & Cheapest Email Scraper. 📩 Ideal for lead gen, outreach, and market research—efficient, reliable, and budget-friendly. 🚀 Save time, boost results!

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

## Pricing

from $1.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Eventbrite Email Scraper - Fast, Advanced and Cheapest 📬

**Eventbrite Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Eventbrite based on the keywords and email-domain filters you provide. It helps solve the common problem of finding the right contact emails without spending days manually searching—whether you’re a marketer, researcher, or data analyst looking to build an **Eventbrite attendee email list**, a business building an **Eventbrite leads email extraction** workflow, or a team doing **bulk Eventbrite email scraping** to power outreach.

With Eventbrite email scraper results tailored by your **keywords** and **custom email domains** (for example `@gmail.com`), you can collect lead contact data faster and at scale—saving you hours of manual work.

---

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

| Feature | Benefit |
| --- | --- |
| ✅ **Keyword-based email extraction** | Finds relevant contact emails using your provided keywords. |
| ✅ **Custom email-domain filtering** | Focuses results on the domains you care about (e.g. `@gmail.com`, `@yahoo.com`). |
| ✅ **Structured output dataset** | Saves each match with keyword, title, description, URL, and email for easy use downstream. |
| ✅ **Reliability with resume support** | Saves progress so you can resume without starting over. |
| ✅ **Cost control with max emails limit** | Stops when your requested `maxEmails` is reached to manage run time. |
| ✅ **Scales across keyword × domain combinations** | Runs through your keyword list and custom domains to expand coverage. |

---

### Key features

- ✅ **Accurate email extraction**: Extracts email addresses from publicly available Eventbrite web content.
- 🔎 **Input flexibility for targeting**: Use `keywords` (required), optional `location`, and `customDomains` to steer results.
- 🛡️ **Built-in resilience & fallbacks**: Includes logic to handle empty/bad pages and continue working when possible.
- 💾 **Incremental dataset saving**: Pushes each discovered email record to the dataset as it’s found.
- 🔄 **Resume progress automatically**: Persists cursor state and already-seen emails so reruns pick up where they left off.
- 🌐 **Dataset-ready fields**: Each row includes `keyword`, `title`, `description`, `url`, and `email`—ideal for analysis and outreach.
- 🎯 **Max limit control**: Use `maxEmails` (up to 10,000) to cap how many unique emails the run collects.

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords to guide what contacts to look for on Eventbrite. This is the main targeting input. |
| `location` | ❌ No | Location text used to filter results. Leave empty for no location filtering. |
| `customDomains` | ❌ No | A list of email domains (like `@gmail.com` or `@yahoo.com`) to prefer while extracting emails. |
| `maxEmails` | ❌ No | Maximum number of **unique** emails to collect. The run stops once this limit is reached. Higher limits can take longer. |

***

### Output

The actor saves results into the **Eventbrite Emails Dataset** dataset in JSON format (one item per extracted email match).

Example pushed record:

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

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label used for each record (`"Eventbrite.com"`). |
| `keyword` | string | The keyword that produced the match in the current run. |
| `title` | string | The title text pulled from the result item (or `"No title"` if missing). |
| `description` | string | Extracted text/description where the email was found (or `"No data"` / missing-derived fallback). |
| `url` | string | The URL associated with the match (or `"No URL"` if missing). |
| `email` | string | The extracted email address. |

> You can export the dataset after the run as JSON/CSV from the Apify Console output tab (dataset export options depend on your workspace settings).

***

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

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find this actor**\
   Search for **Eventbrite Email Scraper - Fast, Advanced and Cheapest** in the Actors marketplace.

3. **Open the Input panel**\
   In the actor run screen, find the **INPUT** section.

4. **Enter your targeting settings**\
   Add at least `keywords` (required). Optionally set:
   `location` to focus by region, and `customDomains` to prefer specific email types like `@gmail.com`.

5. **Choose your limit**\
   Set `maxEmails` to control how many unique emails the run collects (default is `20`).\
   Note: if you run on a free plan, there is an enforced free-tier maximum of `100` emails.

6. **Run the actor**\
   Click **Run**. During execution, you’ll see log updates and progress behavior in real time (including resuming behavior if the run continues).

7. **Review the dataset output**\
   After completion, open the dataset named **Scraped Leads** in the **OUTPUT** tab.

8. **Export results**\
   Export the dataset to JSON/CSV and plug it into your CRM, spreadsheet, or analysis pipeline.

No coding required—get accurate Eventbrite email scraper results in minutes.

***

### Advanced features & SEO optimization

- ⚡ **Engineered for Eventbrite email scraper use cases**: Designed for extracting emails from Eventbrite events and pages using your provided keywords and domain filters (great for “Eventbrite attendee email list” building).
- 🎛️ **Input normalization & smarter targeting**: You can provide multiple `keywords` and refine results using `location` and `customDomains` to improve relevance.
- 🧭 **Resume-ready scraping runs**: Progress is saved so reruns continue from the last cursor position and avoid re-collecting already-seen emails.
- 📊 **Max limit to balance speed and cost**: `maxEmails` helps control runtime so you can run “fast” while still targeting the most useful domains.
- 🧾 **Transparent structured records**: Each record includes `keyword`, `title`, `description`, `url`, and `email`, making it easier to audit and clean data later.

***

### Best use cases

- 📈 **Sales teams building outbound lists**: Generate an Eventbrite leads email extraction starter dataset for outreach campaigns.
- 🎓 **Recruiters sourcing event-related contacts**: Extract emails to contact managers/founders involved with Eventbrite listings.
- 🔍 **Market researchers mapping communities**: Build an Eventbrite email database by topic, role, and domain preferences for analysis.
- ✉️ **Digital marketers running lead-gen experiments**: Rapidly test different keyword and domain strategies for bulk Eventbrite email scraping.
- 🧠 **Data analysts cleaning contact data at scale**: Use the structured dataset fields (`url`, `keyword`, `email`) to deduplicate and enrich.
- 🧩 **Automation workflows and pipelines**: Feed scraped results into downstream tools for CRM import or spreadsheet reporting.
- 🧾 **Compliance-aware lead sourcing (process-focused)**: Focus collection using your chosen keywords and email domains to reduce noise before validation and outreach.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings (required)
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of strings like `@gmail.com` (optional)
  - ✅ `maxEmails` as an integer (optional; min `1`, max `10000`)

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

- **Retry Mechanism**
  - ✅ Includes resilience logic (handles empty results and continues with fallback behavior)

- **Dataset Structure**
  - ✅ Dataset: **Eventbrite Emails Dataset**
  - ✅ Default view: **Scraped Leads**
  - ✅ Fields: `keyword`, `title`, `description`, `url`, `email` (with `network` also present in pushed rows)

- **Rate Limits & Performance**
  - ✅ Execution time depends on result volume and your `maxEmails` target
  - ✅ Larger searches or higher limits can take longer

- **Limitations**
  - ❌ No guarantee of reaching your exact `maxEmails` (results can be limited by available publicly available data)
  - ❌ Emails are extracted only when present in the publicly available content the actor processes

***

### FAQ

#### ✅ Does this Eventbrite email scraper extract emails from Eventbrite pages and listings?

Yes. The actor extracts email addresses from publicly available sources on Eventbrite while using your provided `keywords`, optional `location`, and `customDomains` filters.

#### ✅ What are “custom email domains” used for?

Custom email domains (like `@gmail.com` or `@yahoo.com`) are used to filter which extracted emails are accepted. This helps you focus on the contact types that best match your outreach goals—commonly used for Eventbrite contact email extractor workflows.

#### ✅ Can I control how many emails I get?

Yes. Set `maxEmails` to cap the run by the number of **unique** emails collected. If you request a higher number, it can increase runtime, and results still depend on available public data.

#### ❌ Do I need an API key or coding to run it?

No coding is required. You can provide inputs in Apify Console, run the actor, and export the resulting dataset.

#### 💻 Can I integrate this into a larger workflow?

Yes. The output is saved to a dataset with consistent fields (`keyword`, `title`, `description`, `url`, `email`), which you can export and load into spreadsheets, CRMs, or data pipelines.

#### 🔁 Does the actor support resuming if the run is interrupted?

Yes. It saves progress (including a cursor position and `seen_emails`) so subsequent runs can continue instead of restarting from scratch.

#### ⚖️ Is this tool extracting private or authenticated data?

No. The actor is designed to work with **publicly accessible sources**. It does not access private profiles or password-protected or authenticated content.

***

### Support & feature requests

If you’re using **Eventbrite Email Scraper - Fast, Advanced and Cheapest** for Eventbrite email scraper projects and want improvements, we’d love to hear from you.

- 💡 **Feature Requests**: Ideas like CSV export formatting, additional output fields, or custom domain/validation options are welcome.
- 📧 **Contact**: Share your request via <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for better Eventbrite attendee email email list extraction results.

***

*Ready to mine Eventbrite attendee contact scraping data? **Eventbrite Email Scraper - Fast, Advanced and Cheapest** is the most comprehensive, SEO-optimized way to get your Eventbrite email scraping results at scale.*

***

### Disclaimer

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

You are responsible for ensuring your use complies with applicable laws and regulations (including GDPR/CCPA where relevant), spam requirements, and the target platform’s terms of service.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

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

List of custom email domains

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

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

## Actor input object example

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

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Email Scraper Fast Advanced And Cheapest",
        "description": "⚡️ Extract targeted Eventbrite attendee & event data fast with the Fast Advanced & Cheapest Email Scraper. 📩 Ideal for lead gen, outreach, and market research—efficient, reliable, and budget-friendly. 🚀 Save time, boost results!",
        "version": "1.0",
        "x-build-id": "wKepshGBdffvBt9No"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-eventbrite-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapers-hub~eventbrite-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-eventbrite-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapers-hub~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-eventbrite-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
