# Ticketmaster Radar — Presale Codes, Alerts & On-Sale (`bovi/ticketmaster-radar`) Actor

**Stateful change-feed for Ticketmaster events** — NOT a one-shot dump. Tracks: (1) **Presale & on-sale calendar** — named windows + ISO times from presaleDates\[] (zero incumbents ship this).

- **URL**: https://apify.com/bovi/ticketmaster-radar.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Automation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.75 / 1,000 on-sale / presale alerts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Ticketmaster On-Sale & Presale Radar

**The only Ticketmaster actor that ships a stateful change-feed** — not a one-shot dump. The Radar tracks three data types that zero incumbents ship, rebuilt every run by diffing the current payload against the previous run's state stored in Apify KV.

### What Makes This Actor Different

Every other Ticketmaster actor on the Apify Store is a one-shot metadata dump. They scrape and return the same static fields each run. The Radar is designed for **scheduled monitoring** — you set it to run hourly or daily, and it only emits events that actually changed. No noise, no duplicate data, no manual diffing.

| Feature | This actor | easyapi/ticketmaster-events-scraper | parseforge/ticketmaster-scraper |
|---|:---:|:---:|:---:|
| Presale calendar (named windows + ISO times) | ✓ | ✗ | ✗ |
| On-sale date tracking | ✓ | partial | partial |
| Change-detection between runs | ✓ | ✗ | ✗ |
| Resale window detection | ✓ | ✗ | ✗ |
| Price delta (Discovery API) | optional | ✗ | partial |
| KV-backed stateful store | ✓ | ✗ | ✗ |
| No advanced-protection dependency | ✓ | ✓ | ✓ |
| Price | $5/1000 | $4.99/1000 | unknown |

### Three Confirmed Data Types

#### 1. Presale & On-Sale Calendar

The actor extracts `presaleDates[]` from Ticketmaster's open search payload — named windows with ISO start and end times. For example, a Taylor Swift show might return:
- `"Amex Presale Tickets®"` — 2025-01-07T10:00:00Z to 2025-01-09T23:59:00Z
- `"Onsale To General Public"` — 2025-01-10T10:00:00Z onwards
- `"Resale"` — separate resale window

Live-verified on 20/20 Olivia Rodrigo events in the pass-3 probe (2026-06-04). **Zero incumbents ship this data.** Resellers and event analysts plan their purchase timing around exactly this data.

#### 2. Availability Change-Detection

Re-polls `/search` on every scheduled run and diffs:
- `soldOut` — event went sold out
- `limitedAvailability` — limited tickets remaining  
- `ticketingStatus` — changes between `PRESALE` / `ON_SALE` / `CANCELLED`
- `eventChangeStatus` — event rescheduled, cancelled, postponed

Emits only the events where something changed (in `delta` mode). The `changed_fields` array in every record tells you exactly what flipped. The `change_type` field gives a single human-readable label: `sold_out_change`, `availability_change`, `status_change`, `presale_calendar_change`, `price_change`, or `new_event`.

#### 3. Price Delta (Optional)

When you supply a free Ticketmaster Discovery API key (available at developer.ticketmaster.com), the actor enriches each event with `priceRanges` (min/max, currency) and tracks price changes between runs. Without the key, the actor still extracts price ranges that appear in the search payload — coverage is lower but setup is zero.

### How to Use

#### Basic presale monitor (no API key required)

```json
{
  "queries": ["Taylor Swift", "Coldplay"],
  "maxEventsPerQuery": 100,
  "stateMode": "delta"
}
````

Schedule this run to repeat every 6–12 hours. Only new and changed events will appear in the dataset.

#### Presale-only filter

```json
{
  "queries": ["Beyonce", "Drake"],
  "stateMode": "presale",
  "maxEventsPerQuery": 200
}
```

Returns only events that have presale calendar data — ideal for resellers who want to plan presale purchases.

#### Full export with price tracking

```json
{
  "queries": ["EDC Las Vegas 2025"],
  "stateMode": "full",
  "discoveryApiKey": "YOUR_FREE_KEY_HERE",
  "maxEventsPerQuery": 400
}
```

### Output Fields

| Field | Description |
|---|---|
| `id` | Ticketmaster event ID |
| `name` | Event name |
| `event_date` | Event date (YYYY-MM-DD) |
| `onsale_date` | On-sale date |
| `presale_dates` | Array of `{name, start, end}` presale windows |
| `presale_count` | Number of presale windows |
| `has_presale` | True if any presale window exists |
| `has_general_onsale` | True if a "general public" onsale window exists |
| `has_resale_window` | True if a resale window exists |
| `sold_out` | Boolean — is the event sold out? |
| `limited_availability` | Boolean — limited tickets remaining? |
| `ticketing_status` | ON\_SALE / PRESALE / CANCELLED / etc. |
| `event_change_status` | Rescheduled, postponed, cancelled signal |
| `price_min` | Minimum ticket price |
| `price_max` | Maximum ticket price |
| `price_currency` | Currency code |
| `segment` / `genre` / `subgenre` | Event classification |
| `venue_name` / `venue_city` / `venue_state` | Venue details |
| `changed_fields` | List of fields that changed since last run |
| `change_type` | Single label: `new_event`, `sold_out_change`, etc. |
| `is_new` | True if first time this event was seen |
| `url` | Ticketmaster event URL |
| `scraped_at` | ISO timestamp of this run |

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `queries` | string\[] | required | Search terms to monitor |
| `maxEventsPerQuery` | integer | 100 | Max events to fetch per query |
| `stateMode` | `delta`/`full`/`presale` | `delta` | What to emit |
| `discoveryApiKey` | string | — | Ticketmaster Discovery API key (optional) |
| `proxyConfiguration` | object | — | Apify proxy config (RESIDENTIAL recommended) |

### Pricing — Pay Per Changed Event

**$5.00 per 1,000 records** (PPE — pay per result). In `delta` mode you only pay for events that actually changed or are new — not for scanning 100 events to find 3 changed ones. The stateful design means a reseller monitoring 50 artists pays almost nothing on quiet days and only pays when presales open or availability shifts.

### Access Approach

Uses the robots-permitted HTML `/search` path only. Confirmed 200 from Apify datacenter IPs with 8× rapid sequential requests, no advanced-protection challenge triggered (pass-3 live probe, 2026-06-04). Apify RESIDENTIAL proxy is recommended for high-frequency scheduled runs to avoid shared-DC-IP rate-limits on Fastly CDN.

The protection-walled ISMDS tier (per-seat live inventory) is intentionally excluded — it is robots-Disallowed and requires a browser-minted access token. This actor does not promise per-seat data.

### Use with AI Agents (MCP)

Callable as a tool from AI agents via Apify MCP:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=bovi/ticketmaster-radar",
        "--header",
        "Authorization: Bearer <YOUR_APIFY_TOKEN>"
      ]
    }
  }
}
```

***

*Not affiliated with Ticketmaster or Live Nation. Uses the robots-permitted HTML search surface.*

### Integrations

Built for ticket resellers and event-industry analysts tracking presale windows, on-sale dates, and price deltas over time — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Sofascore Live Events](https://apify.com/bovi/sofascore-live-events)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

Load this actor as a tool in your AI assistant. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-ticketmaster-radar": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/ticketmaster-radar"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~ticketmaster-radar/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"queries": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

## `queries` (type: `array`):

List of search terms to monitor on Ticketmaster. Each item is a free-text query sent to www.ticketmaster.com/search. Examples: 'Taylor Swift', 'Coldplay NYC', 'EDC Las Vegas 2025'. Add multiple queries to monitor several artists or events in one run. Schedule this actor to re-run hourly or daily to detect changes.

## `maxEventsPerQuery` (type: `integer`):

Maximum number of events to fetch and track per search query. Each page returns ~20 events. Higher values increase coverage but cost more compute. Default 100 covers 5 pages — enough for most artist tours. Increase to 400+ for broad genre/city monitoring.

## `stateMode` (type: `string`):

Controls which events are emitted to the dataset and charged. 'delta' (default, recommended): only NEW and CHANGED events since the last run — ideal for scheduled monitors, minimal noise. 'full': all events on every run — useful for first-time bulk export or auditing. 'presale': only events that have presale/on-sale calendar data — useful for resellers who care specifically about presale windows.

## `discoveryApiKey` (type: `string`):

Optional: your Ticketmaster Discovery v2 API key (free at developer.ticketmaster.com — 5,000 API calls/day default). When provided, the actor enriches each event with priceRanges (min/max price, currency) from the official Discovery API, enabling price-delta tracking between runs. Leave empty to use the price data already present in the search payload (less reliable but zero setup).

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

Apify proxy configuration. Recommended: use Apify RESIDENTIAL proxy to avoid shared-datacenter IP rate-limits on Ticketmaster's Fastly CDN. The open /search path does not require residential for basic operation, but a residential pool provides headroom for high-frequency scheduled runs. If left empty, the actor uses direct (no proxy) — which works fine for infrequent runs.

## Actor input object example

```json
{
  "queries": [
    "Taylor Swift",
    "Olivia Rodrigo"
  ],
  "maxEventsPerQuery": 100,
  "stateMode": "delta",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Ticketmaster Radar records (change\_type, name, event\_date, onsale\_date, ticketing\_status, sold\_out, price\_min, price\_max, venue\_name, venue\_city, url, scraped\_at).

# 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 = {
    "queries": [
        "Taylor Swift",
        "Olivia Rodrigo"
    ],
    "maxEventsPerQuery": 100,
    "stateMode": "delta",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/ticketmaster-radar").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 = {
    "queries": [
        "Taylor Swift",
        "Olivia Rodrigo",
    ],
    "maxEventsPerQuery": 100,
    "stateMode": "delta",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/ticketmaster-radar").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 '{
  "queries": [
    "Taylor Swift",
    "Olivia Rodrigo"
  ],
  "maxEventsPerQuery": 100,
  "stateMode": "delta",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/ticketmaster-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ticketmaster Radar — Presale Codes, Alerts & On-Sale",
        "description": "**Stateful change-feed for Ticketmaster events** — NOT a one-shot dump. Tracks: (1) **Presale & on-sale calendar** — named windows + ISO times from presaleDates[] (zero incumbents ship this).",
        "version": "0.1",
        "x-build-id": "Pk3cIcmTuzIZ4nKxA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~ticketmaster-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-ticketmaster-radar",
                "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/bovi~ticketmaster-radar/runs": {
            "post": {
                "operationId": "runs-sync-bovi-ticketmaster-radar",
                "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/bovi~ticketmaster-radar/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-ticketmaster-radar",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries / Artists / Keywords",
                        "type": "array",
                        "description": "List of search terms to monitor on Ticketmaster. Each item is a free-text query sent to www.ticketmaster.com/search. Examples: 'Taylor Swift', 'Coldplay NYC', 'EDC Las Vegas 2025'. Add multiple queries to monitor several artists or events in one run. Schedule this actor to re-run hourly or daily to detect changes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEventsPerQuery": {
                        "title": "Max Events Per Query",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of events to fetch and track per search query. Each page returns ~20 events. Higher values increase coverage but cost more compute. Default 100 covers 5 pages — enough for most artist tours. Increase to 400+ for broad genre/city monitoring.",
                        "default": 100
                    },
                    "stateMode": {
                        "title": "Output Mode",
                        "enum": [
                            "delta",
                            "full",
                            "presale"
                        ],
                        "type": "string",
                        "description": "Controls which events are emitted to the dataset and charged. 'delta' (default, recommended): only NEW and CHANGED events since the last run — ideal for scheduled monitors, minimal noise. 'full': all events on every run — useful for first-time bulk export or auditing. 'presale': only events that have presale/on-sale calendar data — useful for resellers who care specifically about presale windows.",
                        "default": "delta"
                    },
                    "discoveryApiKey": {
                        "title": "Ticketmaster Discovery API Key (optional)",
                        "type": "string",
                        "description": "Optional: your Ticketmaster Discovery v2 API key (free at developer.ticketmaster.com — 5,000 API calls/day default). When provided, the actor enriches each event with priceRanges (min/max price, currency) from the official Discovery API, enabling price-delta tracking between runs. Leave empty to use the price data already present in the search payload (less reliable but zero setup)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Recommended: use Apify RESIDENTIAL proxy to avoid shared-datacenter IP rate-limits on Ticketmaster's Fastly CDN. The open /search path does not require residential for basic operation, but a residential pool provides headroom for high-frequency scheduled runs. If left empty, the actor uses direct (no proxy) — which works fine for infrequent runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
