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

📩 Fast, advanced & cheapest Eventbrite email scraper to extract targeted attendee/organizer contacts fast. Great for marketing, lead gen & agencies. Save time, boost outreach, and get leads instantly! 🚀

- **URL**: https://apify.com/solid-scraper/eventbrite-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 📬

**Eventbrite Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Eventbrite based on the keywords and filters you choose. If you’re looking for an **Eventbrite email scraper**, **Eventbrite contact scraper**, or an **Eventbrite event email scraper tool**, this actor helps you turn public listings into usable lead data—especially when you need an **Eventbrite registration email list** for outreach or research. Whether you're a marketer, recruiter, or data enthusiast, it automates the tedious part of building an **Eventbrite leads email scraper** dataset—saving you hours of manual work.

---

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

| Feature | Benefit |
| --- | --- |
| ✅ **Email extraction from Eventbrite** | Collect email addresses tied to your chosen keywords and filters in one run |
| ✅ **Keyword + email-domain targeting** | Use `customDomains` (e.g., `@gmail.com`) to focus results on specific email types |
| ✅ **Resume support for long runs** | Continues from saved progress if a run stops before reaching your target |
| ✅ **Reliability via retries and fallbacks** | Includes retry logic and resilience improvements to reduce interruptions |
| ✅ **Structured dataset output** | Pushes consistent records to the dataset so it’s easy to export and analyze |
| ✅ **Controlled scaling with limits** | Use `maxEmails` to manage how much data you want to collect per run |

---

### Key features

- ✅ **Accurate Eventbrite email extraction**: Extracts email addresses from publicly available Eventbrite pages using your provided keywords and `customDomains`.
- 🎯 **Flexible targeting inputs**: Supports multiple `keywords`, optional `location`, and multiple email domains to improve match quality.
- 🛡️ **Resilient run behavior**: Includes logic that stops efficiently when results are exhausted, and can retry when results are blocked/empty.
- 🔄 **Resume-ready progress**: Saves progress during execution so you can continue scraping without losing already found emails.
- 📊 **Clear, structured output**: Each found email is pushed into the dataset with keyword, title/description, URL, and email.
- 💾 **Incremental dataset saving**: Records are pushed as they are found, reducing the risk of losing data during long runs.

---

### Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | Yes | A list of keywords or queries to search for on Eventbrite and find relevant email addresses. |
| `location` | No | Location to filter results. Leave empty if you don’t want location filtering. |
| `customDomains` | No | List of custom email domains (for example `@gmail.com`, `@yahoo.com`). Emails matching these domains are prioritized. |
| `maxEmails` | No | Maximum number of emails to collect. The scraper stops once this limit is reached. Higher limits can take longer and do not guarantee reaching the exact number. (Allowed range: minimum `1`, maximum `10000`.) |

***

### Output

The actor pushes data into the **Apify dataset** in JSON format (one record per found email).

Example dataset 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 name. In this actor it is set to `Eventbrite.com`. |
| `keyword` | string | The keyword from your input that led to this result. |
| `title` | string | Title text associated with the result (falls back to `No title` if missing). |
| `description` | string | Extracted description text from the result (may be `No data` if missing). |
| `url` | string | URL associated with the result (falls back to `No URL` if missing). |
| `email` | string | The extracted email address. |

> Notes: The actor deduplicates emails during the run (it tracks `seen_emails`) and stops when it reaches `maxEmails` (or when results are exhausted).

***

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

1. **Open Apify Console**: Log in at https://console.apify.com.
2. **Find the actor**: Search for **Eventbrite Email Scraper - Fast, Advanced and Cheapest** in the Actors marketplace.
3. **Go to the INPUT panel**: You’ll see fields corresponding to `keywords`, `location`, `customDomains`, and `maxEmails`.
4. **Enter your extraction criteria**:\
   Add one or more items in **keywords** (required). Optionally set **location** and **customDomains** for better relevance.
5. **Choose your data cap (optional)**:\
   Set **maxEmails** to control how many emails you want to collect for this run.
6. **Run the actor**:\
   Start the run and monitor logs. The actor pushes results incrementally and saves progress so long runs can resume.
7. **Review your dataset output**:\
   After completion, open the dataset (it appears as **Scraped Leads**) and export your data (JSON/CSV) from there.

No coding required—get accurate **Eventbrite attendee email database** results in minutes.

***

### Advanced features & SEO optimization

- 🔎 **Keyword-focused extraction for Eventbrite email scraper use cases**: Built for **Eventbrite attendee email extractor** and **Eventbrite guest email finder** workflows where relevance depends on your keywords and domain filters.
- 🧭 **Input normalization for better coverage**: Handles keywords as a list and ensures the run has valid defaults.
- 🧱 **Progress persistence for reliability**: Keeps a saved cursor so you can resume and continue harvesting without restarting from scratch.
- ⏱️ **Run-time controls**: Uses an execution timeout concept via Apify **Run Options** (default described as 3600 seconds / 1 hour) and stops intelligently when results dry up.
- 💾 **Consistent lead records**: Each pushed dataset row includes `keyword`, `title`, `description`, `url`, and `email`, making it easy to build an **Eventbrite bulk email extraction** pipeline.

***

### Best use cases

- 📈 **Lead generation for event organizers**: Quickly assemble an **Eventbrite event email scraper tool** dataset to support outreach and partnerships.
- 🧑‍💼 **Recruiting and HR sourcing**: Build a targeted **Eventbrite registration email list** using job-title style keywords (e.g., manager, founder) and preferred domains.
- 🎯 **B2B marketing enrichment**: Enrich CRM records by extracting contact emails that match business-friendly domains for **Eventbrite leads email scraper** workflows.
- 🔬 **Market research & audience mapping**: Analyze what types of roles show up across events by pairing `keyword` with the resulting contact emails.
- 🗂️ **Data analysts building lead datasets**: Use the structured dataset fields (`url`, `email`, `description`) for downstream cleaning and scoring.
- 🧪 **Testing outreach hypotheses**: Launch small batches with a low `maxEmails` first, then scale up based on result quality for **fast Eventbrite email scraper** planning.
- 🔁 **Bulk extraction operations**: Use higher `maxEmails` to support larger **Eventbrite bulk email extraction** initiatives while keeping costs under control via the built-in limit.

***

### Technical specifications

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

- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping (includes retries and fallbacks for resilience)

- **Retry Mechanism**
  - ✅ Includes retry logic and stopping conditions for empty/blocked result patterns

- **Dataset Structure**
  - ✅ Dataset: **Eventbrite Emails Dataset**
  - ✅ View: **Scraped Leads**
  - ✅ Transformation fields: `keyword`, `title`, `description`, `url`, `email`

- **Rate Limits & Performance**
  - ✅ Uses pagination with delays between pages and stops efficiently when no new emails are found

- **Limitations**
  - ❌ No guarantee it will reach `maxEmails` (results depend on what’s publicly available and matches your filters)
  - ❌ Emails found are limited to what the actor can extract into the dataset (deduplicated during the run)

***

### FAQ

#### What does Eventbrite Email Scraper - Fast, Advanced and Cheapest extract?

✅ It extracts email addresses from Eventbrite records that match your provided `keywords` and (optionally) `customDomains` and `location`. The results are pushed to the dataset with fields like `keyword`, `title`, `description`, `url`, and `email`.

#### Do I need to provide keywords?

✅ Yes. `keywords` is required. The actor uses them to drive which pages it looks at for matching emails.

#### What should I put in customDomains?

✅ `customDomains` is a list of email domain strings such as `@gmail.com` or `@yahoo.com`. Using domain filters can improve relevance and help you build a cleaner **Eventbrite attendee email database**.

#### Why might I get fewer emails than my maxEmails value?

✅ Because results depend on what publicly available data matches your keywords and domain filters. The actor also stops when it detects extended lack of new emails, so it may finish before reaching your target.

#### Is there a free tier limit?

❌ If you run on Apify with a free (non-paying) plan, the actor applies a cap of **100 emails maximum**. On a paid plan, that limitation is not applied.

#### Can I resume a run if it stops early?

✅ Yes. The actor saves progress during execution (including which cursor position it reached and which emails were already found) and resumes from saved state.

#### Where do the results go?

✅ The actor pushes rows incrementally to the dataset view called **Scraped Leads**, and you can export the dataset from the Apify Console (JSON/CSV options available there).

***

### Support & feature requests

Want to improve **Eventbrite Email Scraper - Fast, Advanced and Cheapest** for your **Eventbrite email scraper** workflow?\
💡 Feature Requests: If you’d like enhancements like additional export formats, more filtering options, or custom lead fields, share your idea and tell us what outcome you want (for example, better **Eventbrite registration email list** quality or easier CRM ingestion).\
📧 Contact: Reach out at <dataforleads@gmail.com>.

Your feedback directly shapes the roadmap—helping make this **Eventbrite email extraction** tool even better over time.

***

*Built for fast, advanced, and cost-conscious Eventbrite email extraction—so you can scale your lead building with confidence.*

***

### Disclaimer

**This actor accesses publicly accessible sources only**. It does not access private profiles, authenticated content, or password-protected data. It’s your responsibility to comply with applicable laws (for example GDPR/CCPA where relevant), spam regulations, and the platform’s terms of service.

If you need data removal, contact <dataforleads@gmail.com>. Always 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("solid-scraper/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("solid-scraper/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 solid-scraper/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=solid-scraper/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": "📩 Fast, advanced & cheapest Eventbrite email scraper to extract targeted attendee/organizer contacts fast. Great for marketing, lead gen & agencies. Save time, boost outreach, and get leads instantly! 🚀",
        "version": "1.0",
        "x-build-id": "mqk3pHrSpfToT5fjb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~eventbrite-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~eventbrite-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
