# Eventbrite Scraper - Scrape Events & Organizers (`logiover/eventbrite-scraper`) Actor

Eventbrite API alternative - scrape events without an API key. Export prices, venues & organizer leads as CSV/JSON dataset. No login.

- **URL**: https://apify.com/logiover/eventbrite-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Business
- **Stats:** 7 total users, 3 monthly users, 49.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Eventbrite Scraper - scrape events, prices & organizers

Scrape Eventbrite events by keyword, city or search URL and export a clean dataset of every event - dates, venues, geo, ticket prices and organizer contact details. This **Eventbrite events scraper** reads the site's own search data, so there is no login and no API key.

It is two tools in one: an **events dataset** for calendars, research and dashboards, and a **B2B lead-gen engine** - every row carries the organizer's own website and social handles, and event organizers are buyers.

### What you get

One flat row per event. Fields include:

- **id / name / url** - Eventbrite event id, title and public page URL
- **summary** - short event description
- **startDate / startTime / endDate / endTime / timezone** - full schedule
- **isOnline / isFree / isSoldOut / hasAvailableTickets** - quick filter flags
- **minPrice / maxPrice / currency** - ticket price range
- **venueName / address / city / region / postalCode / country** - full localized location
- **latitude / longitude** - venue geo coordinates
- **organizerName / organizerUrl** - organizer name and Eventbrite profile
- **organizerWebsite** - organizer's own website (lead-gen)
- **organizerTwitter / organizerFacebook** - organizer social handles
- **organizerFollowers / organizerUpcomingEvents** - organizer reach signals
- **imageUrl / ticketsUrl** - cover image and checkout URL
- **publishedAt / scrapedAt** - publish and scrape timestamps

Export the dataset to **CSV, JSON, Excel**, HTML, or pull it via the Apify API and webhooks. A ready-made Events Overview table view ships with every run.

### Use cases

- **Event sponsorship & marketing leads** - build lists of organizers (with website + socials) running events in your niche or city.
- **Market & competitive research** - track who runs what, where, when and at what price point.
- **Event aggregators & calendars** - power a city or topic calendar from a scheduled run.
- **Ticketing & pricing analysis** - price ranges, sell-out signals, free-vs-paid mix, geographic spread.
- **Datasets & ML** - a clean, structured events corpus for analytics or models.

### How to use

1. Click **Try for free** / **Start**.
2. Easiest path: open Eventbrite, filter to your city/category, and paste the address-bar URL into **Search URLs** (e.g. `https://www.eventbrite.com/d/ny--new-york/all-events/`). Location and filters are read from the URL.
3. Or run a free-text **Keyword** search across all of Eventbrite; combine it with **Online events only**, a **Date range** and a **Price** filter.
4. Set **Max results (total)** and optionally **Max results per search** to cap volume.
5. Leave the **proxy** on the default (datacenter is plenty).
6. Run it, then download the results as CSV, JSON or Excel from the **Storage / Dataset** tab.

#### Example input

```json
{
  "searchUrls": ["https://www.eventbrite.com/d/ny--new-york/all-events/"],
  "maxResults": 500
}
````

Or a keyword search for online, free events:

```json
{
  "query": "startup pitch night",
  "onlineOnly": true,
  "priceFilter": "free",
  "maxResults": 200
}
```

#### Example output

```json
{
  "name": "CURLFEST 2026",
  "url": "https://www.eventbrite.com/e/curlfest-2026-tickets-...",
  "startDate": "2026-06-25", "startTime": "18:00",
  "timezone": "America/New_York",
  "isFree": false, "isSoldOut": false, "hasAvailableTickets": true,
  "minPrice": 35.61, "maxPrice": 120.00, "currency": "USD",
  "venueName": "Power Station at BerkleeNYC",
  "address": "321 W 44th St, New York, NY 10036",
  "city": "New York", "region": "NY", "country": "US",
  "latitude": 40.794065, "longitude": -73.967,
  "organizerName": "Curly Girl Collective",
  "organizerWebsite": "https://www.curlfest.com/",
  "organizerTwitter": "ilovecgc",
  "organizerFacebook": "curlfest",
  "organizerFollowers": 18234,
  "ticketsUrl": "https://www.eventbrite.com/checkout-external?eid=...",
  "scrapedAt": "2026-06-05T14:20:15.320Z"
}
```

### How it works

The actor reads Eventbrite's internal search API - the same JSON the website uses - and paginates up to Eventbrite's ~10,000-events-per-search ceiling. Pass multiple search URLs (different cities or categories) to go wider in a single run. Results are de-duplicated and streamed as flat rows.

### FAQ

#### Do I need an Eventbrite account or API key?

No. The Eventbrite scraper reads public search data - no login, no token, nothing to rate-limit on your account.

#### How do I scrape events for a specific city?

Open Eventbrite, filter to your city or category, and copy the URL from the address bar into `searchUrls` (e.g. `https://www.eventbrite.com/d/ny--new-york/all-events/`). The actor reads the resolved location and all filters from the URL. The keyword search is location-agnostic unless the URL specifies a place.

#### Will every event include the organizer website and socials?

Whenever the organizer filled them in on Eventbrite, yes - website, Twitter and Facebook come through. Organizers that left them blank produce `null` for those fields on that event.

#### How many events can I scrape per run?

Eventbrite caps a single search at ~10,000 events (about 500 pages). Pass several `searchUrls` for different cities or categories to scale wider in one run.

#### Can I export to CSV or Excel?

Yes. Every run can be downloaded as CSV, JSON, Excel or HTML, or pulled programmatically through the Apify API and webhooks.

#### Is this an Eventbrite API alternative?

Yes. It reads Eventbrite's own public search data directly, so it works as an Eventbrite API alternative - no developer app, no OAuth token and no API key required.

#### How do I export Eventbrite events to CSV or JSON?

Run the actor, then open the Storage / Dataset tab and download the Eventbrite event data as CSV or JSON (Excel and HTML are also available). The same dataset is reachable through the Apify API.

#### Can I scrape Eventbrite without an API key or login?

Yes. The scraper pulls publicly available event data without an API key and without logging in, so nothing is tied to or rate-limited against your Eventbrite account.

***

### Changelog

#### 2026-06-07

- Docs: added coverage for using this as an Eventbrite API alternative, exporting Eventbrite events to CSV/JSON, and scraping without an API key or login.

***

*Collects publicly available event data only. You are responsible for compliance with Eventbrite's Terms and your local regulations, including how you use organizer contact details.*

# Actor input Schema

## `searchUrls` (type: `array`):

Eventbrite search URLs to scrape — copy them straight from the site, e.g. https://www.eventbrite.com/d/ny--new-york/all-events/ or https://www.eventbrite.com/d/online/tech/. Location and filters are read from the URL. Best for a specific city/category.

## `query` (type: `string`):

Free-text keyword search (event title, topic). Use this for a quick keyword search across all of Eventbrite; combine with `onlineOnly` for online events.

## `onlineOnly` (type: `boolean`):

When using the Keyword search, return only online events.

## `dates` (type: `string`):

Time window for results (applies to Keyword search; URL searches keep their own date).

## `priceFilter` (type: `string`):

Filter by ticket price.

## `maxResults` (type: `integer`):

Stop after this many events across all searches. 0 = no limit (Eventbrite caps a single search at ~10,000).

## `maxResultsPerSearch` (type: `integer`):

Cap events per individual search URL/keyword. 0 = no per-search cap.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Recommended for larger runs.

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

Apify Proxy settings. Eventbrite blocks datacenter IPs, so residential proxy is used by default and is required for reliable results.

## `maxConcurrency` (type: `integer`):

How many search URLs/keywords to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.eventbrite.com/d/ny--new-york/all-events/"
  ],
  "onlineOnly": false,
  "dates": "current_future",
  "priceFilter": "all",
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `id` (type: `string`):

Eventbrite event id.

## `name` (type: `string`):

Event title.

## `url` (type: `string`):

Public Eventbrite event page URL.

## `summary` (type: `string`):

Short event summary.

## `startDate` (type: `string`):

Local start date (YYYY-MM-DD).

## `startTime` (type: `string`):

Local start time (HH:MM).

## `endDate` (type: `string`):

Local end date.

## `endTime` (type: `string`):

Local end time.

## `timezone` (type: `string`):

IANA timezone of the event.

## `isOnline` (type: `string`):

Whether the event is online.

## `isFree` (type: `string`):

Whether tickets are free.

## `isSoldOut` (type: `string`):

Whether the event is sold out.

## `hasAvailableTickets` (type: `string`):

Whether tickets are currently available.

## `minPrice` (type: `string`):

Lowest ticket price in the currency.

## `maxPrice` (type: `string`):

Highest ticket price in the currency.

## `currency` (type: `string`):

ISO currency code of the ticket prices.

## `venueName` (type: `string`):

Venue name (null for online events).

## `address` (type: `string`):

Full localized street address.

## `city` (type: `string`):

Venue city.

## `region` (type: `string`):

State / region.

## `postalCode` (type: `string`):

Venue postal/ZIP code.

## `country` (type: `string`):

Country code.

## `latitude` (type: `string`):

Venue latitude.

## `longitude` (type: `string`):

Venue longitude.

## `organizerName` (type: `string`):

Event organizer name.

## `organizerUrl` (type: `string`):

Organizer's Eventbrite profile URL.

## `organizerWebsite` (type: `string`):

Organizer's own website (lead-gen).

## `organizerTwitter` (type: `string`):

Organizer Twitter/X handle.

## `organizerFacebook` (type: `string`):

Organizer Facebook handle/page.

## `organizerFollowers` (type: `string`):

Number of followers on Eventbrite.

## `organizerUpcomingEvents` (type: `string`):

Organizer's number of upcoming events.

## `imageUrl` (type: `string`):

Event cover image URL.

## `ticketsUrl` (type: `string`):

Checkout / tickets URL.

## `publishedAt` (type: `string`):

When the event was published (ISO).

## `scrapedAt` (type: `string`):

Scrape timestamp (ISO).

# 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 = {
    "searchUrls": [
        "https://www.eventbrite.com/d/ny--new-york/all-events/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/eventbrite-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "searchUrls": ["https://www.eventbrite.com/d/ny--new-york/all-events/"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/eventbrite-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    "https://www.eventbrite.com/d/ny--new-york/all-events/"
  ]
}' |
apify call logiover/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Scraper - Scrape Events & Organizers",
        "description": "Eventbrite API alternative - scrape events without an API key. Export prices, venues & organizer leads as CSV/JSON dataset. No login.",
        "version": "1.0",
        "x-build-id": "epSfVYZ5hm9JR7yrO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-eventbrite-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Eventbrite search URLs to scrape — copy them straight from the site, e.g. https://www.eventbrite.com/d/ny--new-york/all-events/ or https://www.eventbrite.com/d/online/tech/. Location and filters are read from the URL. Best for a specific city/category.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword search (event title, topic). Use this for a quick keyword search across all of Eventbrite; combine with `onlineOnly` for online events."
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "When using the Keyword search, return only online events.",
                        "default": false
                    },
                    "dates": {
                        "title": "Date range",
                        "enum": [
                            "current_future",
                            "today",
                            "tomorrow",
                            "this_week",
                            "this_weekend",
                            "next_week",
                            "this_month",
                            "next_month"
                        ],
                        "type": "string",
                        "description": "Time window for results (applies to Keyword search; URL searches keep their own date).",
                        "default": "current_future"
                    },
                    "priceFilter": {
                        "title": "Price",
                        "enum": [
                            "all",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Filter by ticket price.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many events across all searches. 0 = no limit (Eventbrite caps a single search at ~10,000).",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap events per individual search URL/keyword. 0 = no per-search cap.",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Recommended for larger runs.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Eventbrite blocks datacenter IPs, so residential proxy is used by default and is required for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent searches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many search URLs/keywords to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```