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

🚀 Extract attendees, event details & contact signals fast with our Eventbrite Email Scraper (Fast, Advanced & Cheapest). ⚡ Built for lead gen, outreach & market research—accurate results, efficient workflows. ✅ Get started today!

- **URL**: https://apify.com/scraperoka/eventbrite-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

Manually collecting organizer or role-related emails from Eventbrite listings wastes hours you don’t have. **Eventbrite Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Eventbrite using your keywords and email-domain filters—ideal for marketers, recruiters, and growth teams. It’s a fast Eventbrite email scraper and advanced Eventbrite email scraper approach that helps you build lead lists with thousands of records in minutes when paired with the right keywords and domains.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Eventbrite.com",
  "keyword": "manager",
  "title": "Example Eventbrite Organizer Title",
  "description": "Some extracted text that contains contact details.",
  "url": "https://www.eventbrite.com/e/example-event",
  "email": "alex.manager@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for your lead data (`Eventbrite.com`). |
| `keyword` | string | Shows which of your keywords produced the result, so you can refine targeting. |
| `title` | string | Captures the result title that appeared alongside the contact content. |
| `description` | string | Includes the extracted text used for email detection (useful for QA and context). |
| `url` | string | Provides the link associated with the record—handy for verification and enrichment. |
| `email` | string | The extracted email address that you can use for outreach. |
| `charged_event_name` | string | The actor pushes results with `charged_event_name="result"` (useful for cost monitoring in Apify). |
| `cursor` | object | The scraper maintains progress internally so it can resume where it left off. |
| `seen_emails` | array | Tracks unique emails already collected to avoid duplicates across the run. |
| `maxEmails` | integer | A hard stop on how many unique emails to collect (you control it in input). |
| `location` | string | If you set a location filter, it influences which results are considered relevant. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

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

There are a lot of ways to pull Eventbrite contact data—here’s what sets Eventbrite Email Scraper - Fast, Advanced and Cheapest apart.

#### Keyword + email-domain targeting

This advanced Eventbrite email scraper uses your `keywords` and `customDomains` (like `@gmail.com`) to focus on the emails most relevant to your outreach. That means less manual cleaning and fewer irrelevant leads when you’re building an Eventbrite email scraper pipeline.

#### Resilient, resume-friendly runs

The actor maintains progress (`cursor` and `seen_emails`) so it can continue from where it stopped instead of starting from scratch. It also includes resilience logic so your Eventbrite contact email extraction runs stay productive.

#### Clean, deduplicated output

Emails are tracked in `seen_emails`, so you only collect unique addresses up to your `maxEmails` limit. This makes it ideal as an Eventbrite attendee email extractor or Eventbrite event organizer email scraper for lead generation.

#### Built-in proxy support for reliable scraping

Built-in proxy support helps keep scraping reliable when conditions are challenging, supporting a fast Eventbrite email scraper experience for larger workloads.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords or queries the scraper uses to target relevant Eventbrite results for email extraction. |
| `location` | ⬜ | Optional location filter to narrow which Eventbrite results are considered relevant. |
| `customDomains` | ⬜ | Restricts extracted emails to the domains you list (for example, `@gmail.com` and `@yahoo.com`). |
| `maxEmails` | ⬜ | Caps the number of unique emails to collect so your run finishes within your budget and time constraints. |

***

### Core Capabilities

#### Fast lead extraction from Eventbrite

Eventbrite Email Scraper - Fast, Advanced and Cheapest extracts email addresses from Eventbrite based on your provided `keywords`. If you want an Eventbrite email harvesting workflow that doesn’t require manual copy-pasting, this is built for that.

#### Flexible targeting with `location` and `customDomains`

Use `location` to filter results and `customDomains` to focus on the email types that match your outreach strategy. This is especially helpful when running an Eventbrite email scraper bot for lead generation and you care about specific consumer or business domains.

#### Deduplication + controlled run size

The scraper tracks `seen_emails` to prevent duplicates, and it stops once it reaches `maxEmails`. This gives you more predictable output volume—so you can plan list building without guessing.

#### Resume support for long runs

If a run is interrupted, the actor resumes using stored progress (`cursor` and `seen_emails`). That makes it a practical choice for both quick tests and bigger Eventbrite list building tool jobs.

#### Incremental dataset writing

Results are pushed to the dataset as they’re found, rather than waiting until the end. So you can monitor progress and export the dataset when you already have enough contacts.

***

### Who Gets the Most Out of This

Here’s how different teams put Eventbrite Email Scraper - Fast, Advanced and Cheapest to work:

**Growth and Marketing Teams** use it to expand Eventbrite list building tool lead pools by extracting emails tied to job-role style keywords like “manager” or “founder,” while restricting to domains that match campaign targeting. They walk away with cleaner outreach lists faster than manual collection.

**Recruiters and Talent Sourcers** benefit from structured Eventbrite contact email extraction when they need quick access to organizer or role-adjacent contacts. With `customDomains`, they can align results with preferred communication channels and reduce time spent filtering.

**Sales Development Representatives** use the scraper as an Eventbrite contact email extraction engine to build prospect lists for follow-up campaigns. The `maxEmails` cap helps them generate a bounded list for testing before scaling up.

**Freelance Researchers and Lead Gen Analysts** run keyword iterations to compare which search terms produce the most useful email domains, then export the dataset for analysis and enrichment. The dataset fields (`keyword`, `title`, `url`, `email`) make results easy to audit.

**Automation & Data Engineering Specialists** integrate the output into pipelines by exporting from the Apify dataset tab, then feeding it into their systems via Apify’s API. This is a solid Eventbrite data extraction software building block for automated lead workflows.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Eventbrite Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open “Eventbrite Email Scraper - Fast, Advanced and Cheapest”.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `maxEmails` to control volume.
3. **Configure proxy settings** — use Apify Proxy settings for better reliability when running larger jobs.
4. **Hit Run and watch the live log** — monitor progress and see emails being found and pushed.
5. **View results in the dataset tab** — inspect records immediately as they arrive.
6. **Export as JSON, CSV, or Excel** — download when you have the volume you need.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Eventbrite Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export your dataset as **JSON, CSV, or Excel** from the Apify dataset tab for quick imports into spreadsheets, CRMs, and contact tools.

If you want automation, you can connect results using **Apify’s API** (see [apify.com/docs/api](https://apify.com/docs/api)) and push data to downstream systems. You can also automate repeated runs by scheduling the actor, so your Eventbrite email scraper process stays ongoing without manual effort.

***

### Pricing & Free Trial

Eventbrite Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Free tier usage typically includes **platform credits**, enough for several test runs, while production usage is generally pay-as-you-go based on Apify compute units (CU). For exact details on credits, CU pricing, and plan tiers, check the pricing page on Apify.

Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Scraping stability | Built-in proxy support helps keep runs reliable. |
| Safe execution for bigger jobs | Incremental dataset writing and progress tracking help keep progress intact. |
| Output control | `maxEmails` caps unique email collection so runs don’t run away. |
| Deduplication | Emails are tracked via `seen_emails` to avoid duplicates. |
| Resilience | Includes retries and fallbacks for resilience during page retrieval and result availability. |
| Partial recovery | If a run is interrupted, it can resume from stored progress state. |

**Limitations:** The actor extracts emails that appear in publicly available Eventbrite data and filters them by the domains you provide. It cannot extract data that isn’t present in the public content it reads.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier/credits on sign-up, which is enough to run small tests. Your ability to collect larger volumes depends on whether you’re running under the free tier or a paid plan.

#### Do I need to log in to Eventbrite to use this?

No. This actor works with publicly available Eventbrite data and does not require Eventbrite login to extract emails.

#### How accurate is the data?

Accuracy depends on what’s publicly available in the relevant Eventbrite content and whether it contains an email that matches your `customDomains`. The actor extracts emails it detects in the scraped text and records the associated `url` for reference.

#### How many results can I get per run?

You control this with `maxEmails`, which limits the number of unique emails collected. If you run on a free tier, there is an enforced maximum of 100 emails.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor—each run extracts emails from currently accessible public pages. For up-to-date lists, rerun on a schedule.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat this as extracting **publicly available data** and handle it responsibly under your local rules. Compliance with GDPR, CCPA, applicable privacy laws, and Eventbrite’s terms is ultimately your responsibility.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, which you can then import into Google Sheets or other tools. You can also integrate via API for automated workflows.

#### Can I run this on a schedule automatically?

Yes. You can schedule the actor to run automatically so your Eventbrite email harvesting stays continuous without manual intervention.

#### Can I access this via API?

Yes. You can trigger runs and retrieve results programmatically using the Apify API. See [apify.com/docs/api](https://apify.com/docs/api) for details.

#### What happens if the actor hits an error?

The actor writes results incrementally to the dataset and stores progress (`cursor` and `seen_emails`) so you can recover without losing everything already captured. It also includes retries and fallbacks to improve resilience.

***

### Need Help or Have a Request?

Got a question about Eventbrite Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to support improvements like batch CSV upload or a webhook notification when runs finish.

***

### Disclaimer & Responsible Use

*Eventbrite Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract emails for lead generation — start your free run today.*

This actor collects **publicly available data** from Eventbrite. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, applicable privacy laws, and Eventbrite’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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 scraperoka/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=scraperoka/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 attendees, event details & contact signals fast with our Eventbrite Email Scraper (Fast, Advanced & Cheapest). ⚡ Built for lead gen, outreach & market research—accurate results, efficient workflows. ✅ Get started today!",
        "version": "1.0",
        "x-build-id": "KG3B7g4qKXXajnGUM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~eventbrite-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
