# DICE Events Scraper (`automation-lab/dice-events-scraper`) Actor

🎟️ Export public DICE events with dates, venues, prices, categories, ticket limits, refund rules, coordinates, and images.

- **URL**: https://apify.com/automation-lab/dice-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## DICE Events Scraper

Export public DICE events into a structured dataset for calendars, market research, venue intelligence, and ticket monitoring.

The Actor reads DICE city browse pages directly—no login or private API key required—and returns event dates, venues, prices, categories, ticket limits, refund rules, coordinates, and images.

### What does DICE Events Scraper do?

DICE Events Scraper turns public `dice.fm/browse/...` pages into one clean row per event.

Use it to:

- 🎟️ collect concerts, club nights, festivals, comedy, talks, and cultural events
- 📍 build venue and city event inventories
- 💷 compare exact and “from” ticket prices
- 📅 refresh event calendars on a schedule
- 🧭 capture venue addresses and coordinates
- 🔎 filter events by DICE category tags
- 🧾 retain ticket limits and public refund terms

### Who is it for?

#### Concert promoters

Track competing dates, venues, categories, and prices in cities where you operate.

#### Venues

Monitor local programming and identify crowded or open calendar periods.

#### Tourism and event calendars

Feed upcoming events into city guides, newsletters, and destination websites.

#### Nightlife researchers

Build repeatable snapshots of club programming by market and category.

#### Ticket-market analysts

Compare listed prices, availability status, limits, and refund policies.

#### Developers and data teams

Consume normalized JSON through the Apify API, webhooks, integrations, or MCP.

### Why use this Actor?

- No DICE account is needed for public browse pages.
- HTTP extraction is fast and economical.
- Multiple cities can be processed in one run.
- Duplicate event IDs are removed automatically.
- Prices are normalized from minor units to major currency units.
- Output includes provenance through `sourceBrowseUrl`.
- Optional Apify Proxy support is built in.

### What data can you extract?

| Field | Description |
|---|---|
| `id` | Stable DICE event ID |
| `title` | Event title |
| `url` | Public event URL |
| `status` | Ticket availability status |
| `startDate` | ISO event start time |
| `endDate` | ISO event end time |
| `timezone` | Venue timezone |
| `categories` | DICE event tags |
| `venueName` | Venue name |
| `venueAddress` | Full venue address |
| `venueLatitude` | Venue latitude |
| `venueLongitude` | Venue longitude |
| `city` | Venue city |
| `country` | Venue country |
| `currency` | Ticket currency |
| `price` | Exact ticket price |
| `priceFrom` | Lowest advertised price |
| `maxTickets` | Per-order ticket limit |
| `refundPolicy` | Public refund policy type |
| `refundWindowHours` | Cooling-off window |
| `imageUrl` | Event artwork URL |
| `presentedBy` | Presenter or promoter text |
| `sourceBrowseUrl` | Browse page used |
| `scrapedAt` | Collection timestamp |

### How to scrape DICE events

1. Open a public city page on DICE.
2. Copy the full `/browse/` URL.
3. Paste it into **DICE browse URLs**.
4. Optionally add more city pages.
5. Optionally enter category filters such as `DJ` or `Rock`.
6. Choose the maximum number of events.
7. Click **Start**.
8. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input

```json
{
  "startUrls": [
    { "url": "https://dice.fm/browse/london-54d8a23438fe5d27d500001c?lng=en" }
  ],
  "categories": ["DJ"],
  "maxItems": 30
}
````

Available controls:

- `startUrls`: DICE browse URLs using Apify’s URL-list editor.
- `cityUrls`: plain strings convenient for API automation.
- `citySlug`: the complete city slug copied from a browse URL.
- `categories`: optional case-insensitive tag filters.
- `maxItems`: maximum unique events to save.
- `proxyConfiguration`: optional Apify Proxy configuration.

If no location input is supplied, the Actor uses London as a helpful first-run example.

### Output example

```json
{
  "id": "6a4f8840d143800001643d48",
  "title": "ALISHA",
  "url": "https://dice.fm/event/ry8kay-alisha-20th-nov-here-at-outernet-london-tickets",
  "status": "on-sale",
  "startDate": "2026-11-20T23:00:00+00:00",
  "timezone": "Europe/London",
  "categories": ["DJ"],
  "venueName": "HERE at Outernet",
  "venueAddress": "Denmark St, London, UK",
  "currency": "GBP",
  "priceFrom": 19.64,
  "maxTickets": 6,
  "refundPolicy": "cooling_off_enabled"
}
```

Optional values are omitted when DICE does not publish them. An event may have `price`, `priceFrom`, or neither (for example, a free or not-yet-priced event).

### Category filtering

Category matching uses the tags DICE publishes with each event.

Examples include:

- DJ
- Rock
- Electronic
- Comedy
- Theatre
- Talk
- Film
- Food & drink

Matching is case-insensitive and accepts partial tag text. Multiple filters use OR logic.

### Multiple cities and deduplication

Pass several browse pages through `startUrls` or `cityUrls`.

The Actor processes them in order and stops at `maxItems`.

If the same event appears on more than one supplied page, only the first occurrence is saved. Deduplication uses the stable DICE event ID.

### How much does it cost to scrape DICE events?

This Actor uses pay-per-event pricing:

- a small run-start charge
- a charge for each dataset item produced
- automatic volume discounts by Apify pricing tier

HTTP extraction keeps compute usage low. The Apify Console displays the exact price before each run. Set a low `maxItems` for a small trial, then scale to your required markets.

### Scheduling a DICE event monitor

Use Apify Schedules to run the Actor daily, weekly, or at any custom interval.

A common workflow is:

1. Save one task per market or region.
2. Run each task every morning.
3. Send a webhook when the run finishes.
4. Store or compare event IDs in your system.
5. Alert on new events, changed prices, or status changes.

The Actor returns snapshots; change detection can be implemented in your database, automation platform, or downstream Actor.

### Integrations

Send DICE event records to:

- Google Sheets for editorial calendars
- Airtable for venue and promoter research
- Make for no-code event workflows
- Zapier for notifications and CRM updates
- Slack for new-event alerts
- webhooks for custom ingestion pipelines
- Amazon S3 or Google Drive for archives

Use Apify’s dataset export URLs when another system needs CSV or JSON without an SDK.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dice-events-scraper').call({
  citySlug: 'london-54d8a23438fe5d27d500001c',
  maxItems: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/dice-events-scraper').call(run_input={
    'citySlug': 'london-54d8a23438fe5d27d500001c',
    'maxItems': 30,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~dice-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"citySlug":"london-54d8a23438fe5d27d500001c","maxItems":30}'
```

### Use with Apify MCP

Connect AI assistants through the actor-scoped [Apify MCP](https://mcp.apify.com?tools=automation-lab/dice-events-scraper) endpoint. Authenticate with your Apify account when your MCP client opens the authorization flow.

#### Claude Code MCP setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/dice-events-scraper"
```

Confirm the server is available with `claude mcp list`, then ask Claude Code to run the Actor.

#### Claude Desktop and Cursor MCP setup

Add the following server to the `mcpServers` object in your Claude Desktop configuration or to `.cursor/mcp.json`, then restart the client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/dice-events-scraper"
    }
  }
}
```

#### VS Code MCP setup

Create or update `.vscode/mcp.json`, then start the server from VS Code's MCP servers view:

```json
{
  "servers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/dice-events-scraper"
    }
  }
}
```

Example prompts:

- “Find upcoming DICE DJ events in London and group them by venue.”
- “Export DICE events and highlight tickets under £25.”
- “Compare event counts and median prices across these four cities.”
- “Create a weekend calendar from this DICE browse page.”

### Proxy configuration

Direct requests usually work for public DICE pages.

Enable Apify Proxy when your network cannot reach DICE or when your workflow requires a specific proxy setup. Datacenter proxy is generally the economical first choice. Residential routing should only be used when necessary.

### Performance tips

- Put the most important city pages first.
- Use `maxItems` to bound run size.
- Avoid submitting duplicate URLs.
- Filter categories only when you need a narrower dataset.
- Schedule refreshes at a frequency appropriate for your use case.
- Reuse stable event IDs in downstream databases.

### Data quality notes

DICE controls the source data.

Some events do not publish an exact price, end time, refund window, or full venue before onsale. Those optional fields may be absent.

Dates are returned as ISO timestamps with the source timezone offset. Prices are numeric major units: an upstream value of 1964 pence becomes `19.64` GBP.

### Troubleshooting

#### Why did I receive fewer events than `maxItems`?

`maxItems` is a ceiling, not a guarantee. A browse page may publish fewer events, category filters may remove rows, or duplicate events may occur across supplied pages.

#### Why is `price` missing but `priceFrom` present?

DICE uses “from” pricing when multiple ticket types or price levels are available. The Actor preserves that distinction rather than presenting the lowest price as an exact price.

#### Why was my URL rejected?

Only public HTTPS DICE browse URLs are accepted. Use a URL beginning with `https://dice.fm/browse/` rather than an individual event, account, or checkout URL.

#### Why are no category matches returned?

Use category names visible on the supplied DICE page. Tags differ by city and event inventory.

### Legality: is it legal to scrape DICE?

This Actor accesses public pages without bypassing authentication. You are responsible for ensuring that your use complies with applicable laws, DICE terms, copyright, privacy requirements, and contractual obligations.

Collect only data you need, use reasonable run frequency, and avoid republishing protected content without permission. This information is not legal advice.

### Responsible use

- Respect the source website and avoid excessive schedules.
- Do not use output for spam or unlawful profiling.
- Keep personal data handling proportionate and lawful.
- Attribute event information where your use case requires it.
- Delete stale records according to your retention policy.

### Related scrapers

Explore other event and location tools from [automation-lab](https://apify.com/automation-lab):

- combine event data with venue and map enrichment
- export datasets into broader market-research pipelines
- use monitoring Actors to detect changes between snapshots

Only automation-lab Actors are recommended here so ownership and support expectations stay clear.

### Support

If a public DICE browse page fails, open an issue from the Actor page and include:

- the browse URL
- a sanitized input example
- the run ID
- the expected result
- the observed result

Do not include passwords, private tokens, or personal checkout data.

### FAQ

#### Does it require a DICE login?

No. It targets public city browse pages.

#### Can it scrape several cities?

Yes. Supply several browse URLs in one run.

#### Can I export CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and other formats.

#### Does it scrape individual event-detail pages?

It derives rich records from browse-page structured data. This keeps runs fast and avoids extra requests.

#### Can I use the output commercially?

Your permitted use depends on the source terms, data rights, and applicable law. Review those requirements for your project.

#### Are sold-out events included?

They can be included when DICE publishes them on the supplied browse page. Check `status` for availability context.

#### Are prices always available?

No. Free, announced, waiting-list, or not-yet-priced events may not expose a numeric price.

#### How are duplicate events handled?

Rows with the same DICE event ID are saved once per run.

# Actor input Schema

## `startUrls` (type: `array`):

One or more public dice.fm/browse city or filtered browse URLs.

## `cityUrls` (type: `array`):

Plain URL alternative for automation workflows.

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

Full DICE city slug from its browse URL, for example london-54d8a23438fe5d27d500001c.

## `categories` (type: `array`):

Optional case-insensitive tag filters such as DJ, Rock, or Electronic. Leave empty for every event.

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

Stop after saving this many unique events across all pages.

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

Optional Apify Proxy settings. Direct requests work for most public DICE pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://dice.fm/browse/london-54d8a23438fe5d27d500001c?lng=en"
    }
  ],
  "cityUrls": [],
  "categories": [],
  "maxItems": 20
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://dice.fm/browse/london-54d8a23438fe5d27d500001c?lng=en"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dice-events-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 = {
    "startUrls": [{ "url": "https://dice.fm/browse/london-54d8a23438fe5d27d500001c?lng=en" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dice-events-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 '{
  "startUrls": [
    {
      "url": "https://dice.fm/browse/london-54d8a23438fe5d27d500001c?lng=en"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/dice-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DICE Events Scraper",
        "description": "🎟️ Export public DICE events with dates, venues, prices, categories, ticket limits, refund rules, coordinates, and images.",
        "version": "0.1",
        "x-build-id": "iLwImXRJdKY9Naa6t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~dice-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-dice-events-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/automation-lab~dice-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-dice-events-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/automation-lab~dice-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-dice-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "🎟️ DICE browse URLs",
                        "type": "array",
                        "description": "One or more public dice.fm/browse city or filtered browse URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "cityUrls": {
                        "title": "City browse URLs",
                        "type": "array",
                        "description": "Plain URL alternative for automation workflows.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "citySlug": {
                        "title": "City slug",
                        "type": "string",
                        "description": "Full DICE city slug from its browse URL, for example london-54d8a23438fe5d27d500001c."
                    },
                    "categories": {
                        "title": "🎵 Category filters",
                        "type": "array",
                        "description": "Optional case-insensitive tag filters such as DJ, Rock, or Electronic. Leave empty for every event.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique events across all pages.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct requests work for most public DICE pages."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
