# AllEvents Scraper (`solidcode/allevents-scraper`) Actor

\[💰 $1.00 / 1K] Collect events from AllEvents.in by city, keyword, or URL. Get titles, dates, venues, addresses, categories, ticket prices, organizers, and interest counts. Filter by category and date across thousands of cities worldwide.

- **URL**: https://apify.com/solidcode/allevents-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## AllEvents Scraper

Pull live events from AllEvents.in at scale — titles, start and end times with timezone, full venue address with latitude and longitude, ticket price ranges, organizer contacts, interest counts, and category tags for concerts, festivals, conferences, workshops, and more across 40,000+ cities. Built for event marketers, sponsorship and lead-generation teams, and market researchers who need comprehensive, structured event data without collecting listings city by city by hand.

### Why This Scraper?

- **Many cities in a single run** — pass an array of cities and sweep all of them at once, instead of one city per run like the basic alternatives.
- **No 100-event ceiling** — set `maxResults` to `0` for a full, uncapped city sweep; collect every available event, not just the first 100.
- **18 native category filters** — Music, Concerts, Festivals, Nightlife & Parties, Comedy, Performing Arts & Theatre, Dance, Arts, Business, Conferences, Workshops, Exhibitions, Sports & Fitness, Food & Drink, Health & Wellness, Community & Causes, Family & Education, and Fashion.
- **7 date-range windows** — Today, Tomorrow, This weekend, This week, This month, Next month, or all upcoming events, applied at the source on city and keyword searches so you only pay for events in your window.
- **Keyword search built in** — pass terms like "jazz", "startup meetup", or "food festival" and each runs its own search, on top of (or instead of) city sweeps.
- **Paste any AllEvents.in link** — a single event page, a city page, a category page, or a search results page; the type is detected automatically.
- **Precise venue location** — full street address plus latitude and longitude on every event, ready to plot on a map or join to a geographic dataset.
- **Ticket pricing and organizer contacts** — minimum and maximum ticket price with currency code, a free/paid flag, plus organizer name and organizer page URL for outreach.
- **Interest signal on every event** — the "interested" count surfaces demand so you can rank events by traction, not just by date.

### Use Cases

**Event Marketing & Promotion**
- Find every upcoming Music or Festival event in your target cities for a campaign
- Rank events by interest count to prioritize the highest-traction opportunities
- Track what is happening "This weekend" or "This week" for timely promotions
- Pull event images and descriptions to populate landing pages and newsletters

**Sponsorship & Lead Generation**
- Build a list of organizers with names and organizer page URLs for outreach
- Target Conferences, Workshops, and Business events for sponsorship pitches
- Filter to paid events with a known ticket-price range to qualify budgets
- Identify high-interest events worth a brand activation or booth

**Market & Competitive Research**
- Measure event density by category across multiple cities
- Compare ticket price ranges between markets and event types
- Track Nightlife & Parties or Food & Drink trends month over month
- Benchmark how many events your competitors are running in a region

**Event Aggregation & Listings**
- Power a "what's on" directory with title, date, venue, geo, and image
- Keep a local events calendar continuously refreshed by city
- Map events with latitude and longitude for a location-based experience
- Feed a recommendation engine with category tags and interest counts

**Travel & Hospitality**
- Surface events near a hotel or destination for guest concierge content
- Plan around festivals and major concerts when forecasting demand
- Bundle "This month" events into destination guides and itineraries

### Getting Started

#### Single City

The simplest run — just name a city:

```json
{
    "cities": ["New York"],
    "maxResults": 100
}
````

#### Multiple Cities, Filtered by Category

```json
{
    "cities": ["London", "Berlin", "Amsterdam"],
    "categories": ["music", "festivals"],
    "maxResults": 200
}
```

#### Cities Filtered by Date

Use `dateRange` to limit a city sweep (or keyword search) to a time window:

```json
{
    "cities": ["New York"],
    "dateRange": "this-weekend",
    "maxResults": 100
}
```

#### Keyword Search

```json
{
    "searchTerms": ["jazz festival", "startup meetup"],
    "dateRange": "this-weekend",
    "maxResults": 50
}
```

#### Direct AllEvents.in URLs

Paste a city page, a category page, a search page, or a single event page:

```json
{
    "startUrls": [
        "https://allevents.in/new-york/all",
        "https://allevents.in/los-angeles/music"
    ],
    "maxResults": 100
}
```

#### Full Sweep

Combine cities, keywords, filters, and an uncapped result count:

```json
{
    "cities": ["Chicago", "Toronto"],
    "searchTerms": ["food festival"],
    "categories": ["food-drink", "music", "nightlife"],
    "dateRange": "all",
    "maxResults": 0
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `cities` | array (string) | `["New York"]` | City names whose events you want to collect, for example "New York" or "London". Add one or many. Leave empty if you are using keyword searches or URLs instead. |
| `searchTerms` | array (string) | `[]` | Words or phrases to search for, such as "jazz", "startup meetup", or "food festival". Each term runs its own search across AllEvents.in. |
| `startUrls` | array (string) | `[]` | Paste AllEvents.in links directly — a city page, a category page, a search results page, or a single event page. The type is detected automatically. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | array (select) | `[]` (all) | Only collect events in these categories. Choose from Music, Concerts, Festivals, Nightlife & Parties, Comedy, Performing Arts & Theatre, Dance, Arts, Business, Conferences, Workshops, Exhibitions, Sports & Fitness, Food & Drink, Health & Wellness, Community & Causes, Family & Education, and Fashion. Leave empty to include every category. |
| `dateRange` | select | `All upcoming events` | When the events take place: All upcoming events, Today, Tomorrow, This weekend, This week, This month, or Next month. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of events to collect for each city, keyword, or URL. Set to `0` to collect all available events. You pay per event returned, so a sensible limit keeps costs predictable. |

### Output

Each event is one flat row in the dataset. Here is a representative result:

```json
{
    "title": "Summer Jazz Festival 2026",
    "url": "https://allevents.in/new-york/summer-jazz-festival-2026/1234567890",
    "eventId": "1234567890",
    "startDate": "2026-07-18T19:00:00-04:00",
    "endDate": "2026-07-18T23:00:00-04:00",
    "timezone": "-04:00",
    "categories": ["Music", "Festivals"],
    "description": "An evening of live jazz featuring local and touring artists...",
    "venueName": "Blue Note",
    "address": "131 W 3rd St, New York, NY 10012",
    "city": "New York",
    "region": "NY",
    "country": "United States",
    "latitude": 40.7308,
    "longitude": -74.0007,
    "priceMin": 25.0,
    "priceMax": 75.0,
    "currency": "USD",
    "isFree": false,
    "interestedCount": 842,
    "organizerName": "NYC Live Music Co.",
    "organizerUrl": "https://allevents.in/o/9876543",
    "imageUrl": "https://cdn.allevents.in/events/summer-jazz-festival.jpg",
    "sourceQuery": "New York",
    "scrapedAt": "2026-06-02T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Event name |
| `url` | string | Canonical AllEvents.in event detail URL |
| `eventId` | string | AllEvents internal event identifier |
| `startDate` | string | Event start datetime (ISO 8601) |
| `endDate` | string | Event end datetime (ISO 8601), nullable |
| `timezone` | string | Event timezone / UTC offset, nullable |
| `categories` | string\[] | Category tags (e.g. Music, Festivals) |
| `description` | string | Short event description, nullable |
| `imageUrl` | string | Banner image URL, nullable |

#### Venue & Location

| Field | Type | Description |
|-------|------|-------------|
| `venueName` | string | Venue name, nullable |
| `address` | string | Full venue street address, nullable |
| `city` | string | City |
| `region` | string | State or region, nullable |
| `country` | string | Country, nullable |
| `latitude` | number | Venue latitude, nullable |
| `longitude` | number | Venue longitude, nullable |

#### Pricing & Interest

| Field | Type | Description |
|-------|------|-------------|
| `priceMin` | number | Minimum ticket price, nullable |
| `priceMax` | number | Maximum ticket price, nullable |
| `currency` | string | Price currency code, nullable |
| `isFree` | boolean | Whether the event is free |
| `interestedCount` | integer | Number of people marked interested, nullable |

#### Organizer & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `organizerName` | string | Event organizer or host name, nullable |
| `organizerUrl` | string | Organizer page URL, nullable |
| `sourceQuery` | string | The city, keyword, or URL that produced this row |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

### Tips for Best Results

- **Start small to validate** — run with `maxResults` set to 25–50 first to confirm the events match what you need, then scale up.
- **Set `maxResults` to `0` for a full city sweep** — this lifts the cap entirely and collects every available event for each input.
- **Filter at the source** — `categories` and `dateRange` each narrow results before collection. They work on separate paths, so use them one at a time: pick a `dateRange` for a city or keyword sweep, or pick `categories` to drill into specific event types (a category run returns all upcoming events in that category).
- **Mix inputs freely** — combine `cities`, `searchTerms`, and `startUrls` in one run; each input is collected independently and tagged with `sourceQuery`.
- **Use a category to get richer detail** — category runs enrich each event with its full `description` and `organizerUrl`, ideal for outreach and content.
- **Target a single page with `startUrls`** — paste one event URL to pull just that event, or a pre-filtered AllEvents.in URL to reuse a search you already built on the site.
- **Rank by `interestedCount`** — sort the output by interest to surface the highest-demand events before deciding where to invest.

### Pricing

**From $1.00 per 1,000 results** — far cheaper than pay-per-start alternatives at any meaningful volume, and you pay only for the events you actually receive. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.115 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.15 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.50 | $10.50 | $10.00 |
| 100,000 | $120.00 | $115.00 | $105.00 | $100.00 |

A "result" is any single event row in the output dataset. The small fixed per-run start fee is additional and depends on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate event marketing, market research, and listing aggregation. Users are responsible for complying with applicable laws and AllEvents.in's Terms of Service. Do not use collected data for spam, harassment, or any unlawful purpose, and handle any personal data, such as organizer contact details, in line with privacy regulations.

# Actor input Schema

## `cities` (type: `array`):

City names whose events you want to collect, for example 'New York' or 'London'. Add one or many. Leave empty if you are using keyword searches or URLs instead.

## `searchTerms` (type: `array`):

Words or phrases to search for, such as 'jazz', 'startup meetup', or 'food festival'. Each term runs its own search across AllEvents.in.

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

Paste AllEvents.in links directly — a city page, a category page, a search results page, or a single event page. The scraper figures out the type automatically.

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

Only collect events in these categories. Leave empty to include every category. Note: when a category is selected, the Date Range filter does not apply (AllEvents has no combined category-and-date view) — a category run returns all upcoming events in that category. Use Date Range on city or keyword searches without a category.

## `dateRange` (type: `string`):

When the events take place. Choose a preset window or include all upcoming events. Applies to city and keyword searches. This filter does not apply when a Category is selected — category runs always return all upcoming events in that category.

## `maxResults` (type: `integer`):

Maximum number of events to collect for each city, keyword, or URL. Set to 0 to collect all available events. You pay per event returned, so a sensible limit keeps costs predictable.

## Actor input object example

```json
{
  "cities": [
    "New York"
  ],
  "searchTerms": [],
  "startUrls": [],
  "categories": [],
  "dateRange": "all",
  "maxResults": 100
}
```

# Actor output Schema

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

Table of events with key fields like title, date, venue, city, and link.

## `details` (type: `string`):

Full per-event detail rows including organizer, address, geo, pricing, and image.

# 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 = {
    "cities": [
        "New York"
    ],
    "searchTerms": [],
    "startUrls": [],
    "categories": [],
    "dateRange": "all",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/allevents-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 = {
    "cities": ["New York"],
    "searchTerms": [],
    "startUrls": [],
    "categories": [],
    "dateRange": "all",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/allevents-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 '{
  "cities": [
    "New York"
  ],
  "searchTerms": [],
  "startUrls": [],
  "categories": [],
  "dateRange": "all",
  "maxResults": 100
}' |
apify call solidcode/allevents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AllEvents Scraper",
        "description": "[💰 $1.00 / 1K] Collect events from AllEvents.in by city, keyword, or URL. Get titles, dates, venues, addresses, categories, ticket prices, organizers, and interest counts. Filter by category and date across thousands of cities worldwide.",
        "version": "1.0",
        "x-build-id": "ELs9VfLmGz9lgc9Zc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~allevents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-allevents-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/solidcode~allevents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-allevents-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/solidcode~allevents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-allevents-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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names whose events you want to collect, for example 'New York' or 'London'. Add one or many. Leave empty if you are using keyword searches or URLs instead.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Keyword Searches",
                        "type": "array",
                        "description": "Words or phrases to search for, such as 'jazz', 'startup meetup', or 'food festival'. Each term runs its own search across AllEvents.in.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste AllEvents.in links directly — a city page, a category page, a search results page, or a single event page. The scraper figures out the type automatically.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect events in these categories. Leave empty to include every category. Note: when a category is selected, the Date Range filter does not apply (AllEvents has no combined category-and-date view) — a category run returns all upcoming events in that category. Use Date Range on city or keyword searches without a category.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "music",
                                "concerts",
                                "festivals",
                                "nightlife",
                                "comedy",
                                "performing-arts",
                                "dance",
                                "arts",
                                "business",
                                "conferences",
                                "workshops",
                                "exhibitions",
                                "sports",
                                "food-drink",
                                "health-wellness",
                                "community",
                                "family-education",
                                "fashion"
                            ],
                            "enumTitles": [
                                "Music",
                                "Concerts",
                                "Festivals",
                                "Nightlife & Parties",
                                "Comedy",
                                "Performing Arts & Theatre",
                                "Dance",
                                "Arts",
                                "Business",
                                "Conferences",
                                "Workshops",
                                "Exhibitions",
                                "Sports & Fitness",
                                "Food & Drink",
                                "Health & Wellness",
                                "Community & Causes",
                                "Family & Education",
                                "Fashion"
                            ]
                        },
                        "default": []
                    },
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "all",
                            "today",
                            "tomorrow",
                            "this-weekend",
                            "this-week",
                            "this-month",
                            "next-month"
                        ],
                        "type": "string",
                        "description": "When the events take place. Choose a preset window or include all upcoming events. Applies to city and keyword searches. This filter does not apply when a Category is selected — category runs always return all upcoming events in that category.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max Results per Input",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of events to collect for each city, keyword, or URL. Set to 0 to collect all available events. You pay per event returned, so a sensible limit keeps costs predictable.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
