# Find Events (`hypebridge/find-events`) Actor

Queries multiple event platforms for a given city and category, returning a single normalized dataset of scheduled events. Supported platforms include Eventbrite, Meetup, Luma, Dice, Eventnoire, Posh, Prekindle, and Shotgun.

- **URL**: https://apify.com/hypebridge/find-events.md
- **Developed by:** [Hypebridge](https://apify.com/hypebridge) (community)
- **Categories:** E-commerce, Integrations, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 orchestration units

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

### What does Find Events do?

Find Events queries multiple primary event platforms for a given city and category, returning a single normalized dataset of scheduled events. Supported platforms include Eventbrite, Meetup, Luma, Dice, Eventnoire, Posh, Prekindle, and Shotgun. The actor matches search parameters, fetches listings, and deduplicates identical events across sources.

### Core Capabilities

- **Unified Querying**: Retrieve events across platforms with a single request, eliminating the need to configure and coordinate multiple individual crawlers.
- **Data Standardization**: All outputs use a single schema regardless of the source platform, including standardized ISO UTC timestamps, locations, and pricing fields.
- **Event Deduplication**: The system merges identical listings found on multiple platforms using title, date, city, and venue heuristics.
- **Cost-Optimized Fallbacks**: The actor runs cost-effective platform queries first, only invoking more expensive crawlers like Eventbrite when earlier sources do not meet the requested volume.

### What data can Find Events extract?

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Event name |
| `platform` | String | Source platform (e.g. `meetup`, `dice`) |
| `sourceUrl` | String | Link to the original event page |
| `category` | String | Canonical category you searched for |
| `startDateTimeUtc` | String | Start time in UTC (ISO 8601) |
| `localDate` | String | Event date in the city's timezone |
| `venueName` / `address` | String | Where the event takes place |
| `city` / `state` / `country` | String | Resolved location |
| `requestedCity` / `locationMatchQuality` | String | Requested city and whether the event was an exact or nearby location match |
| `priceMin` / `priceMax` / `isFree` | Number / Boolean | Ticket pricing when available |
| `imageUrl` | String | Event cover image |
| `description` | String | Event description (richer with details enabled) |
| `sourceFields` | Object | The untouched original record from the source platform |

Duplicates appearing on multiple platforms are merged using title, date, city, and venue.

### Run Configuration

1. Enter the target location in the `city` field (e.g., `Dallas, TX` or `Berlin`).
2. Select a `category` (e.g., `music`, `technology`) and a `timeWindow`.
3. Specify the `maxEvents` limit to define the target number of results.
4. Click **Start** to run the actor and retrieve findings from the **Dataset** tab.

### Cost Structure

Total run costs consist of the orchestration fee for this actor and the fees of the platform-specific crawlers executed on your behalf.

#### 1. Orchestration Fee (Pay Per Event)

| Metric | Cost |
|---|---|
| Run Start | $0.005 |
| Event Delivered | $0.002 ($2.00 per 1,000 events) |

#### 2. Platform Crawlers (Billed Separately)

This actor triggers child runs of platform crawlers (such as Meetup, Luma, or Dice) using your Apify account resources. Platform crawlers charge their own pay-per-event fees, which typically range from $0.002 to $0.011 per event depending on the platform and whether full event details are retrieved. These appear as separate runs on your Apify usage logs.

#### Estimating Total Cost

Combined estimates vary based on city size, category, and the mix of active sources.

| Request Size | Orchestration Fee | Platform Crawlers | Estimated Total |
|---|---|---|---|
| 10 events | ~$0.03 | ~$0.08 to $0.15 | **~$0.10 to $0.18** |
| 50 events | ~$0.11 | ~$0.30 to $0.50 | **~$0.40 to $0.60** |
| 50 events with details | ~$0.11 | ~$0.60 to $0.95 | **~$0.70 to $1.05** |

#### Cost Controls

- **Budget Limit**: You can set a maximum charge limit for the run. The actor automatically sizes and caps child runs to keep total spend below this limit.
- **Max Events**: Set `maxEvents` to limit the volume of processed and delivered items.
- **Event Details**: Setting `getEventDetails` to false reduces platform crawler costs by skipping detailed sub-pages, fetching only the index listing.
- **Expensive Fallbacks**: Setting `useExpensiveFallbacks` to false prevents the actor from starting Eventbrite crawls. Eventbrite requires residential proxies, adding a fixed cost of approximately $0.81 per run. By default, the actor only uses Eventbrite when other platforms cannot satisfy the requested event count.

### Input

See the **Input** tab for the full schema. Key fields:

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `city` | String | `Dallas, TX` | Free-form city, optionally with state or country. |
| `category` | String | `all` | Event category: `music`, `nightlife`, `technology`, `business`, `food_drink`, `arts_culture`, `comedy`, `sports_fitness`, `wellness`, `community_culture`, `family_education`. |
| `timeWindow` | String | `this_month` | `this_week`, `this_month`, or `all`. |
| `maxEvents` | Integer | `50` | Maximum unique events to return. |
| `platforms` | Array | all 8 | Restrict which platforms to search. |
| `getEventDetails` | Boolean | `false` | Fetch full event pages for richer data (slower, costs more). |
| `useExpensiveFallbacks` | Boolean | `true` | Allow Eventbrite when other platforms don't fill the request. |
| `childRunTimeoutSecs` | Integer | auto | Max seconds to wait for any one platform. |

#### Example input

```json
{
  "city": "San Francisco, CA",
  "category": "music",
  "timeWindow": "this_week",
  "maxEvents": 50,
  "platforms": ["dice", "shotgun", "luma"],
  "getEventDetails": true
}
````

### Output

Saved to the **Dataset** tab. Download as JSON, CSV, Excel, or HTML.

Each item includes:

- **Event**: title, description, category, start/end times (UTC and local), status
- **Location**: venue, address, city, state, country, coordinates
- **Pricing**: priceMin, priceMax, currency, isFree
- **Provenance**: platform, sourceUrl, scrapedAt, plus the raw source record in `sourceFields`

#### Sample output

```json
{
  "id": "luma:evt_123",
  "platform": "luma",
  "sourceUrl": "https://lu.ma/ai-builders-dallas",
  "category": "technology",
  "title": "AI Builders Hackathon & Meetup",
  "description": "Join us for an exciting evening of building agentic apps.",
  "startDateTimeUtc": "2026-07-15T23:00:00.000Z",
  "localDate": "2026-07-15",
  "city": "Dallas",
  "state": "TX",
  "venueName": "Capital One Innovation Hub",
  "address": "1900 Pacific Ave, Dallas, TX 75201",
  "priceMin": 0,
  "isFree": true,
  "imageUrl": "https://images.lumacdn.com/event-cover.jpg",
  "scrapedAt": "2026-07-02T23:12:00.000Z"
}
```

### Operational Guidelines

- **Selecting Platforms**: Leaving all platforms selected allows the actor to dynamically prioritize sources based on historical city and category performance.
- **Freshness and Volume**: Use `timeWindow: "this_week"` for time-sensitive listings, or `all` to capture long-term scheduled data.
- **Details vs. Listings**: Enable `getEventDetails` only when rich descriptions, ticket prices, or lineups are required for your database. Skipping details keeps platform crawler costs at their baseline rate.

### FAQ

#### Legal and Compliance

Find Events extracts publicly available event listings. Check the Terms of Service for each source platform and ensure your data collection complies with applicable regulations.

#### Cost Variation Across Runs

Platform distribution varies by city. In smaller markets, the actor may trigger more child crawlers or use the Eventbrite fallback to fulfill the requested event limit. Setting a strict budget hard-caps the run costs.

#### Low Event Volume Behavior

If a city contains fewer events than the `maxEvents` value, the crawler terminates after exhausting all active platforms. You are billed for the $0.005 start fee and the events successfully delivered.

### Support and Feedback

- Report bugs or submit feature requests through the **Issues** tab.
- Reference the **API** tab for details on running this actor programmatically.

#### Privacy and Data Protection Disclaimer

This crawler only extracts public event listings. It does not extract private user details such as personal email addresses, gender, or user locations. Depending on the listings, the returned datasets may contain public personal data (e.g., event host names). Users are responsible for ensuring that their data collection and storage complies with GDPR, CCPA, and other local data protection regulations. Consult legal counsel if you are uncertain about compliance requirements.

# Actor input Schema

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

Canonical event category used to route across supported platforms.

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

Free-form city, optionally including state or country, for example Dallas, TX or New York.

## `timeWindow` (type: `string`):

Filter events to a simple time window. Resolved to concrete start/end dates internally using the resolved city timezone.

## `maxEvents` (type: `integer`):

Maximum number of normalized events to return across all platforms.

## `getEventDetails` (type: `boolean`):

Ask supported child actors to enrich listings with full event-page details. Unsupported child actors ignore this setting.

## `platforms` (type: `array`):

Platforms to include. Leave all selected for best coverage.

## `maxCheapActors` (type: `integer`):

Maximum number of cheap downstream actors to run before considering expensive fallbacks.

## `useExpensiveFallbacks` (type: `boolean`):

Allow Eventbrite and other expensive actors if cheap actors do not produce enough results.

## `minUsefulResults` (type: `integer`):

If a platform returns fewer records than this and maxEvents is not reached, continue to the next platform.

## `childRunTimeoutSecs` (type: `integer`):

Maximum seconds to wait for any one downstream actor.

## `debugMode` (type: `boolean`):

Store route plans, child inputs, pricing decisions, and skipped-platform reasons in the key-value store.

## Actor input object example

```json
{
  "category": "all",
  "city": "Dallas, TX",
  "timeWindow": "this_week",
  "maxEvents": 50,
  "getEventDetails": false,
  "platforms": [
    "luma",
    "meetup",
    "dice",
    "eventnoire",
    "posh",
    "prekindle",
    "shotgun",
    "eventbrite"
  ],
  "maxCheapActors": 5,
  "useExpensiveFallbacks": true,
  "minUsefulResults": 3,
  "childRunTimeoutSecs": 240,
  "debugMode": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing aggregated event records from multiple platforms.

## `files` (type: `string`):

Key-value store files created when debug mode is enabled.

# 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 = {
    "category": "all",
    "city": "Dallas, TX",
    "timeWindow": "this_week",
    "maxEvents": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hypebridge/find-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 = {
    "category": "all",
    "city": "Dallas, TX",
    "timeWindow": "this_week",
    "maxEvents": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hypebridge/find-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 '{
  "category": "all",
  "city": "Dallas, TX",
  "timeWindow": "this_week",
  "maxEvents": 50
}' |
apify call hypebridge/find-events --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Find Events",
        "description": "Queries multiple event platforms for a given city and category, returning a single normalized dataset of scheduled events. Supported platforms include Eventbrite, Meetup, Luma, Dice, Eventnoire, Posh, Prekindle, and Shotgun.",
        "version": "0.0",
        "x-build-id": "XwJQ32Tzmkv1vv6yF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hypebridge~find-events/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hypebridge-find-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/hypebridge~find-events/runs": {
            "post": {
                "operationId": "runs-sync-hypebridge-find-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/hypebridge~find-events/run-sync": {
            "post": {
                "operationId": "run-sync-hypebridge-find-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": [
                    "category",
                    "city",
                    "maxEvents"
                ],
                "properties": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "music",
                            "nightlife",
                            "business",
                            "technology",
                            "food_drink",
                            "arts_culture",
                            "comedy",
                            "sports_fitness",
                            "wellness",
                            "community_culture",
                            "family_education"
                        ],
                        "type": "string",
                        "description": "Canonical event category used to route across supported platforms.",
                        "default": "all"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Free-form city, optionally including state or country, for example Dallas, TX or New York.",
                        "default": "Dallas, TX"
                    },
                    "timeWindow": {
                        "title": "Time window",
                        "enum": [
                            "this_week",
                            "this_month",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter events to a simple time window. Resolved to concrete start/end dates internally using the resolved city timezone.",
                        "default": "this_month"
                    },
                    "maxEvents": {
                        "title": "Max events",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of normalized events to return across all platforms.",
                        "default": 50
                    },
                    "getEventDetails": {
                        "title": "Get event details",
                        "type": "boolean",
                        "description": "Ask supported child actors to enrich listings with full event-page details. Unsupported child actors ignore this setting.",
                        "default": false
                    },
                    "platforms": {
                        "title": "Platforms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Platforms to include. Leave all selected for best coverage.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "eventbrite",
                                "meetup",
                                "luma",
                                "dice",
                                "eventnoire",
                                "posh",
                                "prekindle",
                                "shotgun"
                            ],
                            "enumTitles": [
                                "Eventbrite",
                                "Meetup",
                                "Luma",
                                "Dice",
                                "Eventnoire",
                                "Posh",
                                "Prekindle",
                                "Shotgun"
                            ]
                        },
                        "default": [
                            "luma",
                            "meetup",
                            "dice",
                            "eventnoire",
                            "posh",
                            "prekindle",
                            "shotgun",
                            "eventbrite"
                        ]
                    },
                    "maxCheapActors": {
                        "title": "Max cheap actors",
                        "minimum": 1,
                        "maximum": 7,
                        "type": "integer",
                        "description": "Maximum number of cheap downstream actors to run before considering expensive fallbacks.",
                        "default": 5
                    },
                    "useExpensiveFallbacks": {
                        "title": "Use expensive fallbacks",
                        "type": "boolean",
                        "description": "Allow Eventbrite and other expensive actors if cheap actors do not produce enough results.",
                        "default": true
                    },
                    "minUsefulResults": {
                        "title": "Min useful results",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "If a platform returns fewer records than this and maxEvents is not reached, continue to the next platform.",
                        "default": 3
                    },
                    "childRunTimeoutSecs": {
                        "title": "Child run timeout",
                        "minimum": 30,
                        "maximum": 900,
                        "type": "integer",
                        "description": "Maximum seconds to wait for any one downstream actor.",
                        "default": 240
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Store route plans, child inputs, pricing decisions, and skipped-platform reasons in the key-value store.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```