# Luma Events (`aitorsm/luma-events`) Actor

Scrape events from luma.com — name, dates, venue, pricing, capacity, plus full organizer profile with Instagram, LinkedIn, TikTok, YouTube, and website handles included by default. Built for lead generation, outreach, sponsorship targeting, and event aggregation.

- **URL**: https://apify.com/aitorsm/luma-events.md
- **Developed by:** [Aitor Sanchez-Mansilla](https://apify.com/aitorsm) (community)
- **Categories:** Lead generation, Automation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 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

## Luma Events Scraper - Discover Events, Organizers, and Communities for Lead Generation, Outreach, and Market Intelligence

[![Luma Events Scraper status](https://apify.com/actor-badge?actor=aitorsm/luma-events)](https://apify.com/aitorsm/luma-events)

The **Luma Events Scraper** allows you to efficiently extract event data from [Luma](https://luma.com) — the modern event-discovery platform used by founders, communities, and event organizers worldwide. It returns detailed, structured information for every event, including:

- Event name, description, start/end times, and timezone
- Full venue address with coordinates
- Ticket pricing, availability, sold-out status, and remaining spots
- Live attendance signals (guest count, tickets sold, near-capacity flag)
- **Organizer profile with social handles included by default** — Instagram, LinkedIn, Twitter / X, TikTok, YouTube, website, and verified-account status
- Per-host social handles for events run by multiple people
- Geographic metadata for filtering by city, region, or country

With a **user-friendly visual input**, this tool is built for sales teams, recruiters, sponsorship platforms, and marketing agencies who need fast, reliable access to Luma's organizer ecosystem.

### Use Cases

#### 1. **Organizer Lead Generation**
Identify the most active event organizers in any city and pull their full social-media presence and websites in one pass. Filter for `verified_at`, `subscriber_count`, or `ticket_count` to surface high-value prospects without manual lookup.

#### 2. **Outreach List Building**
Every result already includes the organizer's Instagram, LinkedIn, TikTok, YouTube, and website — ready to be loaded into your CRM or outreach tool. No follow-up enrichment step required.

#### 3. **Sponsorship Targeting**
Score organizers by realized revenue (`ticket_count` × `ticket_info.price`) and by reach (`subscriber_count`) to prioritize the most sponsorable accounts in your category and city.

#### 4. **Recruiting Hosts, Speakers, and Creators**
The `hosts` array on each event lists every person running it, with their personal Instagram, LinkedIn, Twitter, TikTok, and YouTube handles. Perfect for talent scouting, creator partnerships, or speaker booking.

#### 5. **Competitive and Market Intelligence**
Track how often competitors run events, what they charge, which venues they book, and whether they're selling out. Run the scraper on a schedule and diff the output over time to spot momentum shifts.

#### 6. **Event Aggregation for Local Newsletters and Apps**
Pull a clean, structured feed of upcoming events for a city or category and republish it on your "What's Happening in [City]" newsletter, tourism board, hotel concierge, or coworking-space app.

#### 7. **Lead Enrichment for Existing Lists**
Already have a list of organizer names or slugs? Use the `organizer` search mode to pull every event they've run (past, future, or both) along with their full social and website profile — great for enriching outbound prospect lists.

#### 8. **Cross-Platform Organizer Database**
Combine Luma data with Eventbrite, Meetup, or other event-platform datasets to build a unified, multi-source organizer database. The shared fields (name, social handles, website, city) make deduplication straightforward.

#### 9. **Trend and Niche Discovery**
Use the `category` mode (`tech`, `ai`, `climate`, `crypto`, `fooddrink`, `arts`, `fitness`, `wellness`) to track emerging communities, hot topics, and rising organizers in a vertical you care about.

> **Coming soon:** keyword search, date range filtering, and an optional per-event detail enrichment (full description + ticket-type breakdown). [Drop me a line](mailto:business@aitorsm.com) if any of these would unblock a use case for you — it helps me prioritize.

### Cost

This Actor uses pay-per-event pricing with tiered rates:
- **No subscription** - $0.03 per Event Scraped

Apify's platform costs are included, so the total amount is totally predictable for you.

### Input

The input is designed around four search modes, picked via the **`searchType`** dropdown. Fill in only the field(s) your chosen mode needs.

- **`searchType`** — pick one:
  - `city` — return every upcoming event in a city.
  - `cityAndCategory` — return events in a city filtered by category.
  - `category` — return events in a category, biased toward the runner's geographic location. Use `cityAndCategory` instead if you want a predictable geographic scope.
  - `organizer` — return every event from one organizer (past, future, or all).
- **`city`** — the Luma city slug as it appears in the URL (e.g. `barcelona` for `luma.com/barcelona`, `sf` for San Francisco, `nyc` for New York, `la` for Los Angeles, `dc` for Washington). The actor also accepts human-friendly variants like `"New York"`, `"san francisco"`, `"los angeles"`. See [luma.com/discover](https://luma.com/discover) for the full canonical list.
- **`category`** — one of: `tech`, `ai`, `climate`, `crypto`, `fooddrink`, `arts`, `fitness`, `wellness`.
- **`organizer`** — either the calendar slug from the URL (e.g. `innerflowstudio` from `luma.com/innerflowstudio`) or the internal id (`cal-Mu5whmr6zoIz1Yz`). Both work; the slug is more convenient if you copy-paste from a browser.
- **`period`** — for organizer mode only: `future` (default), `past`, or `all`. Use `past` to backfill an organizer's full event history.
- **`maxItems`** — optional cap on how many events to return. Leave blank to fetch everything available.

Feel free to reach out if you need more advanced filtering options!

### Output

The data is returned in **JSON format**, ideal for direct ingestion into analytics platforms, CRMs, dashboards, or downstream pipelines. Below is a real example of a single event entry from the Los Angeles feed:

```json
{
  "api_id": "evt-TLZB1y7FGB8qFtm",
  "event": {
    "api_id": "evt-TLZB1y7FGB8qFtm",
    "calendar_api_id": "cal-Or0NdeYS6Dd43c4",
    "cover_url": "https://images.lumacdn.com/event-covers/ah/869cf83c-7037-4e0b-b917-40e308e860f6.png",
    "name": "The Dinner Table at Telefèric Barcelona (Brentwood)",
    "start_at": "2026-05-22T02:00:00.000Z",
    "end_at": "2026-05-22T05:00:00.000Z",
    "timezone": "America/Los_Angeles",
    "event_type": "independent",
    "location_type": "offline",
    "visibility": "public",
    "geo_address_info": {
      "city": "Los Angeles",
      "region": "California",
      "country": "United States",
      "country_code": "US",
      "sublocality": "Brentwood",
      "full_address": "Telefèric Barcelona Los Angeles, 11930 San Vicente Blvd, Los Angeles, CA 90049, USA",
      "short_address": "11930 San Vicente Blvd, Los Angeles"
    },
    "coordinate": { "longitude": -118.4712044, "latitude": 34.052285 }
  },
  "calendar": {
    "api_id": "cal-Or0NdeYS6Dd43c4",
    "name": "The Dinner Table Club",
    "slug": "thedinnertable_club",
    "description_short": "Dinner Parties With Strangers In Your City 🥂",
    "avatar_url": "https://images.lumacdn.com/calendars/p5/29867af3-0cb8-41c8-aef0-b1cdbc6c77e6",
    "website": "https://www.thedinnertable.club/",
    "instagram_handle": "thedinnertable_club",
    "linkedin_handle": "/company/the-dinner-table-club",
    "twitter_handle": null,
    "tiktok_handle": "thedinnertable_club",
    "youtube_handle": "TheDinnerTable_Club",
    "verified_at": "2023-08-05T05:54:47.835Z",
    "luma_plan": "plus",
    "location": {
      "city": "New York",
      "country": "United States",
      "country_code": "US",
      "timezone": "America/New_York"
    },
    "geo_city": "New York",
    "geo_country": "United States"
  },
  "hosts": [
    {
      "api_id": "usr-IND6JbMKj3oA1wV",
      "name": "The Dinner Table Club",
      "username": "thedinnertable",
      "website": "https://thedinnertable.club/",
      "instagram_handle": "thedinnertable_club",
      "linkedin_handle": "/in/the-dinner-table-club",
      "tiktok_handle": "thedinnertable_club",
      "youtube_handle": "TheDinnerTable_Club",
      "twitter_handle": null,
      "is_verified": false
    }
  ],
  "guest_count": 12,
  "ticket_count": 12,
  "ticket_info": {
    "price": { "cents": 9500, "currency": "usd", "is_flexible": false },
    "is_free": false,
    "is_sold_out": false,
    "spots_remaining": 8,
    "is_near_capacity": false,
    "require_approval": false
  },
  "registration_availability": "open"
}
````

#### Fields

- **Event name and description** — `event.name`, plus a short cover image and theme colors.
- **Dates and timezone** — `event.start_at` and `event.end_at` (ISO 8601 UTC) plus the local `event.timezone`.
- **Venue and geography** — full address, sublocality, country, and `coordinate` (latitude / longitude).
- **Organizer profile** — name, slug, avatar, description, **website**, **Instagram, LinkedIn, Twitter, TikTok, YouTube handles**, verified-account flag, location, and Luma plan tier.
- **Hosts** — each individual running the event, with their personal social handles.
- **Pricing and capacity** — price (in cents + currency), free flag, sold-out flag, **spots remaining**, near-capacity flag, and whether the event requires approval to attend.
- **Live attendance signals** — `guest_count`, `ticket_count` — useful for ranking events by traction.

#### Simplified Overview

A simplified view of this data will be shown directly in the **Apify console**, where you can see a table of key event details including organizer, date, location, and ticket info.

```json
{
  "event.name": "The Dinner Table at Telefèric Barcelona (Brentwood)",
  "event.start_at": "2026-05-22T02:00:00.000Z",
  "event.geo_address_info.city_state": "Los Angeles, California",
  "calendar.name": "The Dinner Table Club",
  "calendar.instagram_handle": "thedinnertable_club",
  "calendar.website": "https://www.thedinnertable.club/",
  "ticket_info.price.cents": 9500,
  "ticket_info.is_sold_out": false,
  "ticket_count": 12,
  "spots_remaining": 8
}
```

***

### How to Use

1. **Pick a search mode**: choose `city`, `cityAndCategory`, `category`, or `organizer` from the **searchType** dropdown.
2. **Fill in the required field(s)**: e.g. `city: "barcelona"` for a city search, or `organizer: "innerflowstudio"` to pull every event from one organizer.
3. **Run the Actor**: start the scraping process. Check the Overview and All Fields tabs to inspect results as they arrive.
4. **Export Data**: once the run is complete, export the dataset in JSON, CSV, Excel, or HTML — directly into your CRM, spreadsheet, dashboard, or pipeline.

***

Start scraping Luma events today by running this Actor on Apify.

### Contact

- **Email**: <business@aitorsm.com> — for custom features, advanced filtering, tailored data products, or anything off-spec.
- **Apify Discord**: find me as `aitor.sm`.

If this actor has been useful to you, please consider adding it to your bookmarks 📑 on Apify.

# Actor input Schema

## `searchType` (type: `string`):

Pick how you want to discover events.

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

The Luma city slug as it appears in the URL (e.g. 'barcelona' from luma.com/barcelona, 'sf' for San Francisco, 'nyc' for New York). Required when searchType is 'city' or 'cityAndCategory'.

## `category` (type: `string`):

Luma category. Required when searchType is 'category' or 'cityAndCategory'.

## `organizer` (type: `string`):

Either the calendar slug from the URL (e.g. 'ehub' from luma.com/ehub) OR the api\_id (e.g. 'cal-Mu5whmr6zoIz1Yz'). Required when searchType is 'organizer'.

## `period` (type: `string`):

For organizer mode: which events to return.

## `maxItems` (type: `integer`):

Leave blank to fetch all available.

## Actor input object example

```json
{
  "searchType": "city",
  "city": "barcelona",
  "period": "future",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "city": "barcelona",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("aitorsm/luma-events").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 = {
    "city": "barcelona",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("aitorsm/luma-events").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 '{
  "city": "barcelona",
  "maxItems": 20
}' |
apify call aitorsm/luma-events --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Events",
        "description": "Scrape events from luma.com — name, dates, venue, pricing, capacity, plus full organizer profile with Instagram, LinkedIn, TikTok, YouTube, and website handles included by default. Built for lead generation, outreach, sponsorship targeting, and event aggregation.",
        "version": "0.1",
        "x-build-id": "JuwaruvfCkGhF62Gu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aitorsm~luma-events/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aitorsm-luma-events",
                "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/aitorsm~luma-events/runs": {
            "post": {
                "operationId": "runs-sync-aitorsm-luma-events",
                "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/aitorsm~luma-events/run-sync": {
            "post": {
                "operationId": "run-sync-aitorsm-luma-events",
                "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": [
                    "searchType"
                ],
                "properties": {
                    "searchType": {
                        "title": "What to search",
                        "enum": [
                            "city",
                            "category",
                            "cityAndCategory",
                            "organizer"
                        ],
                        "type": "string",
                        "description": "Pick how you want to discover events.",
                        "default": "city"
                    },
                    "city": {
                        "title": "City slug",
                        "type": "string",
                        "description": "The Luma city slug as it appears in the URL (e.g. 'barcelona' from luma.com/barcelona, 'sf' for San Francisco, 'nyc' for New York). Required when searchType is 'city' or 'cityAndCategory'."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "tech",
                            "ai",
                            "climate",
                            "crypto",
                            "fooddrink",
                            "arts",
                            "fitness",
                            "wellness"
                        ],
                        "type": "string",
                        "description": "Luma category. Required when searchType is 'category' or 'cityAndCategory'."
                    },
                    "organizer": {
                        "title": "Organizer slug or api_id",
                        "type": "string",
                        "description": "Either the calendar slug from the URL (e.g. 'ehub' from luma.com/ehub) OR the api_id (e.g. 'cal-Mu5whmr6zoIz1Yz'). Required when searchType is 'organizer'."
                    },
                    "period": {
                        "title": "Time period (organizer mode only)",
                        "enum": [
                            "future",
                            "past",
                            "all"
                        ],
                        "type": "string",
                        "description": "For organizer mode: which events to return.",
                        "default": "future"
                    },
                    "maxItems": {
                        "title": "Max events to return",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Leave blank to fetch all available."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
