# TickPick Scraper (`crawlerbros/tickpick-scraper`) Actor

Scrape TickPick.com - the no-fee ticket resale marketplace. Browse live events by city, by performer/team/venue, or by category (sports, concerts, theater). Get real-time no-fee pricing (low/high), venue details, and event schedules.

- **URL**: https://apify.com/crawlerbros/tickpick-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TickPick Scraper

Scrape **TickPick** — the no-fee ticket resale marketplace for concerts, sports, and theater. Browse live events by city, by performer/team, or by venue, or discover performers/teams within a category (MLB, NBA, NFL, concerts, comedy, and 80+ more). Every event record includes TickPick's real no-fee pricing (low/high ticket price), venue address, and performer details. HTTP-only, no auth, no proxy.

### What this actor does

- **Four modes:** `byCity`, `byPerformer`, `byVenue`, `byCategory`
- **60+ cities** and **90 categories/leagues** exposed as dropdown enums
- **Real no-fee pricing** — low/high ticket price straight from TickPick's own event data
- **Filters:** event date range, min/max ticket price
- **Optional enrichment:** `byCategory` mode can additionally fetch each performer's upcoming events
- **Empty fields are omitted** — you'll never see `null`, `""`, or `[]` in the output

### Output per event (`recordType: "event"`)

- `eventId` — TickPick's numeric event ID
- `eventName`, `eventDescription`, `eventImage`
- `startDate`, `endDate`, `eventStatus`, `eventAttendanceMode` (`Offline` / `Online` / `Mixed`)
- `venueName`, `venueUrl`, `venueCity`, `venueState`, `venueCountry`
- `performers[]`, `homeTeam`, `awayTeams[]` (sports events)
- `lowPrice`, `highPrice`, `price`, `priceCurrency`, `availability`
- `ticketUrl` — direct link to buy on TickPick
- `sourceUrl` — canonical event page URL
- `category` — league/category used for the lookup (if applicable)
- `recordType: "event"`, `scrapedAt`

### Output per performer directory entry (`recordType: "performer"`, mode=byCategory)

- `performerName`, `performerSlug`, `category`
- `performerDescription`, `performerImage` (when `enrichEvents` is on)
- `sourceUrl`
- `recordType: "performer"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byCity` | `byCity` / `byPerformer` / `byVenue` / `byCategory` |
| `citySlug` | string (select) | `new-york` | City to browse (mode=byCity) |
| `category` | string (select) | `mlb` | League/category (mode=byPerformer, byCategory) |
| `performerSlugs` | array | `["boston-red-sox"]` | Performer/team URL slugs within `category` (mode=byPerformer) |
| `venueSlugs` | array | `["madison-square-garden"]` | Venue URL slugs (mode=byVenue) |
| `enrichEvents` | boolean | `false` | Also fetch events for each performer found (mode=byCategory) |
| `dateFrom` | string | – | ISO date; drop events before this date |
| `dateTo` | string | – | ISO date; drop events after this date |
| `minPrice` | integer | – | Drop events priced below this (USD) |
| `maxPrice` | integer | – | Drop events priced above this (USD) |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–2000) |

#### Example: upcoming events in a city

```json
{
  "mode": "byCity",
  "citySlug": "new-york",
  "maxItems": 50
}
````

#### Example: a team's home schedule with pricing

```json
{
  "mode": "byPerformer",
  "category": "mlb",
  "performerSlugs": ["boston-red-sox", "new-york-yankees"],
  "dateFrom": "2026-07-01",
  "dateTo": "2026-09-30"
}
```

#### Example: everything at a venue under $200

```json
{
  "mode": "byVenue",
  "venueSlugs": ["madison-square-garden"],
  "maxPrice": 200
}
```

#### Example: discover NBA teams and their schedules

```json
{
  "mode": "byCategory",
  "category": "nba",
  "enrichEvents": true,
  "maxItems": 200
}
```

### Use cases

- **Price tracking** — monitor no-fee low/high prices for a team's home games
- **Event discovery** — build a local "what's on" feed for a city
- **Fan tools** — alert fans when tickets for a favorite artist/team drop below a price threshold
- **Venue analytics** — compare pricing across events at the same venue
- **Market research** — compare resale pricing across categories and cities

### FAQ

**Is this affiliated with TickPick?**
No. This is an independent third-party actor that reads TickPick's own publicly published event data (the same structured data TickPick publishes for search engines).

**Why does TickPick advertise "no fees"?**
TickPick builds its buyer fee into the listed price instead of adding it at checkout — the `lowPrice`/`highPrice` fields already reflect the final price you'd pay.

**Why are some events missing pricing?**
A small number of listings (informational/experience listings, sold-out shows) don't carry an `offers` block on TickPick's page; those fields are simply omitted rather than shown as zero or null.

**Can I look up a performer without knowing its category?**
Not directly — TickPick nests performer pages under a league/category prefix (e.g. `/mlb/boston-red-sox-tickets/`). Use `mode=byCategory` first to discover the exact `performerSlugs` for a given `category`.

**Why does `mode=byCategory` return 0 performers for some categories?**
`byCategory` discovers performers from TickPick's own site-wide navigation menu, which only features a subset of categories (major sports leagues, concerts, comedy, theater, golf, racing, MMA, and similar high-traffic categories). Niche categories (e.g. opera, ballet, circus) aren't listed in that navigation, so discovery returns 0 for them — the category page itself still exists on TickPick, it's just not crawlable this way. If you already know a performer's slug for a niche category, `mode=byPerformer` will still work directly.

**How fresh is the pricing?**
Every run fetches TickPick's live pages directly, so prices reflect the current live market at scrape time.

**Does this cover international events?**
Yes for the cities TickPick itself covers (including London, Toronto, Vancouver, Montreal, Calgary, Edmonton in addition to major US markets).

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `citySlug` (type: `string`):

City to browse upcoming live events in.

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

TickPick event category / league.

## `performerSlugs` (type: `array`):

TickPick performer/team URL slugs within the chosen category, e.g. `boston-red-sox`, `taylor-swift`. Find slugs via mode=byCategory.

## `venueSlugs` (type: `array`):

TickPick venue URL slugs, e.g. `madison-square-garden`, `angel-stadium`.

## `enrichEvents` (type: `boolean`):

When browsing a category, additionally fetch upcoming events (with pricing) for each matched performer/team. Slower — bounded by Max items.

## `dateFrom` (type: `string`):

ISO date (YYYY-MM-DD). Drop events before this date.

## `dateTo` (type: `string`):

ISO date (YYYY-MM-DD). Drop events after this date.

## `minPrice` (type: `integer`):

Drop events whose lowest available price is below this.

## `maxPrice` (type: `integer`):

Drop events whose lowest available price is above this.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byCity",
  "citySlug": "new-york",
  "category": "mlb",
  "performerSlugs": [
    "boston-red-sox"
  ],
  "venueSlugs": [
    "madison-square-garden"
  ],
  "enrichEvents": false,
  "maxItems": 50
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset containing all scraped TickPick events and performer records.

# 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 = {
    "mode": "byCity",
    "citySlug": "new-york",
    "category": "mlb",
    "performerSlugs": [
        "boston-red-sox"
    ],
    "venueSlugs": [
        "madison-square-garden"
    ],
    "enrichEvents": false,
    "maxItems": 50
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "byCity",
    "citySlug": "new-york",
    "category": "mlb",
    "performerSlugs": ["boston-red-sox"],
    "venueSlugs": ["madison-square-garden"],
    "enrichEvents": False,
    "maxItems": 50,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "byCity",
  "citySlug": "new-york",
  "category": "mlb",
  "performerSlugs": [
    "boston-red-sox"
  ],
  "venueSlugs": [
    "madison-square-garden"
  ],
  "enrichEvents": false,
  "maxItems": 50
}' |
apify call crawlerbros/tickpick-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TickPick Scraper",
        "description": "Scrape TickPick.com - the no-fee ticket resale marketplace. Browse live events by city, by performer/team/venue, or by category (sports, concerts, theater). Get real-time no-fee pricing (low/high), venue details, and event schedules.",
        "version": "1.0",
        "x-build-id": "JyTZOlPNCr6Znhccu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tickpick-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-tickpick-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~tickpick-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-tickpick-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~tickpick-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-tickpick-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCity",
                            "byPerformer",
                            "byVenue",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byCity"
                    },
                    "citySlug": {
                        "title": "City (mode=byCity)",
                        "enum": [
                            "anaheim",
                            "arlington",
                            "atlanta",
                            "austin",
                            "baltimore",
                            "boston",
                            "buffalo",
                            "calgary",
                            "charlotte",
                            "chicago",
                            "cincinnati",
                            "cleveland",
                            "columbus",
                            "costa-mesa",
                            "dallas",
                            "denver",
                            "detroit",
                            "duluth",
                            "edmonton",
                            "fresno",
                            "hartford",
                            "houston",
                            "indianapolis",
                            "jacksonville",
                            "kansas-city",
                            "las-vegas",
                            "london",
                            "los-angeles",
                            "louisville",
                            "madison",
                            "memphis",
                            "miami",
                            "milwaukee",
                            "minneapolis",
                            "montreal",
                            "nashville",
                            "new-orleans",
                            "new-york",
                            "oakland",
                            "oklahoma-city",
                            "orlando",
                            "philadelphia",
                            "phoenix",
                            "pittsburgh",
                            "portland",
                            "raleigh",
                            "sacramento",
                            "salt-lake-city",
                            "san-antonio",
                            "san-diego",
                            "san-francisco",
                            "san-jose",
                            "seattle",
                            "stlouis",
                            "tampa",
                            "toronto",
                            "tulsa",
                            "vancouver",
                            "washingtondc",
                            "wilmington"
                        ],
                        "type": "string",
                        "description": "City to browse upcoming live events in.",
                        "default": "new-york"
                    },
                    "category": {
                        "title": "Category (mode=byPerformer, byCategory)",
                        "enum": [
                            "50s-60s-era",
                            "adult",
                            "alternative",
                            "ballet",
                            "baseball",
                            "basketball",
                            "bluegrass",
                            "boxing",
                            "broadway",
                            "children-family",
                            "circus",
                            "cirque-du-soleil",
                            "classical",
                            "college",
                            "comedy",
                            "concerts",
                            "country",
                            "country-folk",
                            "cricket",
                            "dance",
                            "fairs-festivals",
                            "film",
                            "football",
                            "formula-1",
                            "golf",
                            "gymnastics",
                            "hard-rock-metal",
                            "hockey",
                            "holiday",
                            "horse-racing",
                            "jazz-blues",
                            "lacrosse",
                            "laliga",
                            "las-vegas",
                            "las-vegas-shows",
                            "latin",
                            "lecture",
                            "magic-shows",
                            "march-madness",
                            "mixed-martial-arts",
                            "mlb",
                            "mls",
                            "museum-exhibit",
                            "music-festivals",
                            "musical-play",
                            "nascar",
                            "nba",
                            "ncaa-baseball",
                            "ncaa-basketball",
                            "ncaa-football",
                            "ncaa-gymnastics",
                            "ncaa-hockey",
                            "ncaa-lacrosse",
                            "ncaa-soccer",
                            "ncaa-softball",
                            "ncaa-tennis",
                            "ncaa-volleyball",
                            "ncaa-wrestling",
                            "new-age",
                            "nfl",
                            "nhl",
                            "off-broadway",
                            "olympics",
                            "opera",
                            "other",
                            "performance-series",
                            "pga",
                            "pop-rock",
                            "rb-soul",
                            "racing",
                            "rap-hip-hop",
                            "reggae-reggaeton",
                            "religious",
                            "rodeo",
                            "rugby",
                            "skating",
                            "soccer",
                            "softball",
                            "taped-program-(tv-radio)",
                            "techno-electronic",
                            "tennis",
                            "tgl",
                            "theater",
                            "ufc",
                            "volleyball",
                            "west-end",
                            "wnba",
                            "world",
                            "wrestling",
                            "wwe"
                        ],
                        "type": "string",
                        "description": "TickPick event category / league.",
                        "default": "mlb"
                    },
                    "performerSlugs": {
                        "title": "Performer/team slugs (mode=byPerformer)",
                        "type": "array",
                        "description": "TickPick performer/team URL slugs within the chosen category, e.g. `boston-red-sox`, `taylor-swift`. Find slugs via mode=byCategory.",
                        "default": [
                            "boston-red-sox"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "venueSlugs": {
                        "title": "Venue slugs (mode=byVenue)",
                        "type": "array",
                        "description": "TickPick venue URL slugs, e.g. `madison-square-garden`, `angel-stadium`.",
                        "default": [
                            "madison-square-garden"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichEvents": {
                        "title": "Fetch events for each performer (mode=byCategory)",
                        "type": "boolean",
                        "description": "When browsing a category, additionally fetch upcoming events (with pricing) for each matched performer/team. Slower — bounded by Max items.",
                        "default": false
                    },
                    "dateFrom": {
                        "title": "Event date from (inclusive)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD). Drop events before this date."
                    },
                    "dateTo": {
                        "title": "Event date to (inclusive)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD). Drop events after this date."
                    },
                    "minPrice": {
                        "title": "Min ticket price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop events whose lowest available price is below this."
                    },
                    "maxPrice": {
                        "title": "Max ticket price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop events whose lowest available price is above this."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
