# Eventbrite Scraper — Events, Organizers & Demand Signals (`datascoutlab/eventbrite-scraper`) Actor

Scrape Eventbrite events by city, category, keyword or date. Every row carries the venue with coordinates, ticket prices, and the organizer with follower count and social links - resolved without an extra request or an extra charge. Includes Eventbrite's own demand signals.

- **URL**: https://apify.com/datascoutlab/eventbrite-scraper.md
- **Developed by:** [Anton DataScout](https://apify.com/datascoutlab) (community)
- **Categories:** Lead generation, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 event scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Eventbrite Scraper — Events, Organizers & Demand Signals

[![Eventbrite Scraper status](https://apify.com/actor-badge?actor=datascoutlab/eventbrite-scraper)](https://apify.com/datascoutlab/eventbrite-scraper)

**Scrape Eventbrite events** from any city, country or category and get a flat, spreadsheet-ready table of **event data**: venue with coordinates, ticket prices, the organizer with follower count and social links — plus Eventbrite's own demand signals showing which events are actually selling.

Built for **event lead generation**, market research, competitive analysis and event aggregation. No Eventbrite account, no API key, no browser — one request returns 50 events.

### Table of contents

- [Why this Eventbrite scraper](#why-this-eventbrite-scraper)
- [Demand signals — the field nobody else exposes](#demand-signals--the-field-nobody-else-exposes)
- [Use cases](#use-cases)
- [Cost](#cost)
- [Input](#input)
- [Output](#output)
- [How to use it](#how-to-use-it)
- [Working with the data](#working-with-the-data)
- [Run it from AI agents](#run-it-from-ai-agents)
- [Honest limits](#honest-limits)
- [FAQ](#faq)
- [Related Actors](#related-actors)

---

### Why this Eventbrite scraper

Most Eventbrite scrapers hand you an event list. This one answers the question you actually had when you started scraping: **who is behind this event, how big are they, and is it selling?**

| | Typical Eventbrite scraper | This Actor |
|---|---|---|
| Organizer name | ✅ | ✅ |
| Organizer **follower count** | ❌ | ✅ |
| Organizer **social handles** | billed as a separate enrichment step | ✅ included, no extra charge |
| **Demand signals** ("few tickets left") | ❌ | ✅ |
| `isSellingFast` flag | ❌ | ✅ |
| Venue coordinates | sometimes | ✅ lat/lng on every venue |
| Price range | min only | ✅ min **and** max |
| Output shape | nested JSON (`crop_mask`, `edge_color`…) | ✅ flat row, opens straight in Excel |
| Failed pages | silently missing | ✅ reported with the reason |

The organizer block is the part people usually pay twice for — competing Actors charge per enriched organizer and load an extra page for each one. Here it arrives in the same response as the event, so it costs nothing extra and adds no time.

---

### Demand signals — the field nobody else exposes

Eventbrite shows badges like *"Few tickets left"* and *"Sales end soon"* on its own site. They come down in the API response, and this Actor keeps them:

```json
"urgencySignals": ["fewTickets"],
"isSellingFast": true
````

`isSellingFast` is deliberately narrow: **only scarcity counts**. `salesEndSoon` is a deadline, not proof of demand, so it does *not* raise the flag. In a Berlin run of 60 events, 33 carried a signal and 14 were genuinely selling fast.

This is the closest public proxy for how well an event is selling — useful for picking venues, pricing your own event, or ranking leads by how much money they actually move.

***

### Use cases

#### 1. Event lead generation

Build a targeted **event organizer list** for any city: organizer name, follower count, Facebook and Twitter handles, and profile URL on every row. Ideal if you sell to event hosts — catering, ticketing, venues, AV, sponsorship, marketing.

#### 2. Sponsorship prospecting

Sort by `organizerFollowers` to find the organizers with real audiences instead of the ones with the loudest event titles.

#### 3. Event market research

What does a workshop actually cost in Berlin versus Austin? Every row carries min and max ticket price with currency, so you can price your own event off real numbers.

#### 4. Competitive analysis

Schedule a daily run on your category and city, and watch who launches what, at which price, and whether it sells out.

#### 5. Event aggregation

Feed a city or category into your own site or app. Rows are flat and stable, with image URLs, tags, timezone and ticket links included.

#### 6. Venue and demand analysis

Coordinates on every venue plus demand signals show which rooms in a city actually fill up — and which nights they fill on.

#### 7. Demand-based content

Build "Top events this weekend" roundups that rank by real scarcity signals rather than by guesswork.

#### 8. Automated alerts

Run on a schedule and diff the dataset to catch new events in your niche the day they are published.

***

### Cost

Pay per event returned. `maxResultsPerLocation` is a hard ceiling, so the bill is knowable before the run starts — 200 events per location means at most 200 billable rows per location.

Organizer data is **included in that price**. Actors that bill organizer enrichment separately charge for it per unique organizer, on top of the per-event price.

Turning on **Include full description** costs one extra request per event (Eventbrite does not return descriptions in search results), which makes the run slower but does not change the per-event price.

***

### Input

| Field | Description |
|---|---|
| **Locations** | `Berlin, Germany`, a slug like `germany--berlin`, or a full `/d/` URL. Mix freely — each is searched separately. |
| **Category** | One of Eventbrite's 21 categories, or all of them. |
| **Keyword** | Free-text search inside the location — a topic, brand or artist. |
| **Time frame** | Upcoming, today, this weekend, next month… or a custom `startDate`/`endDate` range. |
| **Price** | Free only, paid only, or any. |
| **Online events only** | Online events instead of physical venues. Still needs a location — Eventbrite scopes online events by country. |
| **Max events per location** | Your cost ceiling. Up to 10,000 per search. |
| **Include full description** | Off by default. Adds the full description text at the cost of one extra request per event. |

```json
{
  "locations": ["New York, United States", "Berlin, Germany"],
  "category": "103",
  "dates": "this_weekend",
  "priceFilter": "paid",
  "maxResultsPerLocation": 200
}
```

***

### Output

49 fields per event, all flat. A trimmed sample:

```json
{
  "name": "Out & Abt",
  "startDateTime": "2026-07-25T16:00",
  "venueName": "Elsewhere - The Rooftop",
  "venueCity": "Brooklyn",
  "venueCountry": "US",
  "latitude": 40.709411,
  "longitude": -73.958,
  "minPrice": 18.46,
  "maxPrice": 25.0,
  "currency": "USD",
  "isFree": false,
  "isSoldOut": false,
  "isSellingFast": true,
  "urgencySignals": ["salesEndSoon", "fewTickets"],
  "organizerName": "Elsewhere",
  "organizerFollowers": 12480,
  "organizerTwitter": "elsewherespace",
  "organizerUrl": "https://www.eventbrite.com/o/elsewhere-105655500371",
  "tags": ["Music", "Concert", "Dj"],
  "url": "https://www.eventbrite.com/e/out-abt-tickets-198354591421"
}
```

Fields are grouped into **identity** · **when** (date, time, timezone) · **where** (venue, full address, coordinates) · **money** (min/max price, free, sold out, availability) · **demand** · **organizer** (followers, summary, Facebook, Twitter, profile URL) · **misc** (tags, language, cancelled, series) · **provenance** (which search produced the row).

***

### How to use it

1. Enter one or more **locations** — a city and country is enough.
2. Optionally narrow by **category**, **keyword**, **date range** or **price**.
3. Set **Max events per location** to cap your cost.
4. Click **Start** — a 60-event run finishes in about 10 seconds.
5. Export from the **Storage** tab as CSV, Excel, JSON or XML, or pull it via API.

***

### Working with the data

- **Excel / Google Sheets** — the dataset has a ready `Overview` view with the 26 columns that matter, in a readable order. Export as CSV, or use `IMPORTDATA()` with the dataset CSV link.
- **API** — `GET https://api.apify.com/v2/datasets/<datasetId>/items?format=csv&view=overview`
- **Integrations** — the dataset connects to Make, Zapier, Google Drive, Slack and webhooks from the Apify integrations tab.
- **Scheduling** — run daily or weekly; each run is a fresh dataset, so diffing them gives you new events only.

***

### Run it from AI agents

The Actor exposes a standard input schema, so it works as a tool for LLM agents through Apify's MCP server — an agent can search events, filter by demand signals, and hand back an organizer shortlist without any glue code.

***

### Honest limits

- **Page size is 50.** Eventbrite caps it; asking for 100 silently returns 50.
- **Descriptions are not free.** Eventbrite returns `full_description` as `null` in search results, so the Actor fetches each description separately when you ask for it. That is why the option is off by default — the alternative would be shipping an always-empty column.
- **`organizerUpcomingEvents` is usually `null`.** Eventbrite returns the key but rarely fills it. Kept visible rather than hidden, so you can see it is genuinely empty rather than silently dropped.
- **A failed page is reported, never skipped quietly.** If a request fails after every retry, the reason lands in `RUN_SUMMARY` — an empty result is never disguised as "no more events".
- **Proxy**: datacenter proxies are enough. Residential ones only add cost. Eventbrite rejects some datacenter IPs on some paths, so the Actor retries with a fresh session, a different path and HTTP/1.1 before giving up.

***

### FAQ

**Do I need an Eventbrite account or API key?**
No. This uses Eventbrite's public search — no login, no key, no quota.

**Is this an Eventbrite API alternative?**
For discovery, yes. Eventbrite's official API no longer exposes public event search to third parties; this Actor reads the same search the website uses.

**Can I scrape one organizer's events?**
Search their city with a keyword matching their name, then filter rows by `organizerId`.

**Can I get events near a specific point rather than a whole city?**
Search the city and filter by `latitude`/`longitude` — every venue row carries coordinates.

**How do I find only events that are selling well?**
Filter on `isSellingFast`. It is set only by scarcity signals, not by countdown timers.

**Does it work outside the US?**
Yes — any Eventbrite location. Berlin, London, Barcelona and Paris are all verified in testing.

**Can I run it on a schedule?**
Yes, like any Apify Actor. Daily runs on a category make a clean feed of newly published events.

**Is scraping Eventbrite legal?**
This Actor collects only publicly visible event listings — no login, no personal data behind authentication. As with any scraping, how you use the data is your responsibility.

***

### Related Actors

- [Airbnb Scraper](https://apify.com/datascoutlab/airbnb-scraper) — size up the same local market from the accommodation side.
- [Google Trends Scraper](https://apify.com/datascoutlab/google-trends-reliable) — check whether the topic behind an event is growing before you invest in it.
- [Facebook Ads Library Scraper](https://apify.com/datascoutlab/fb-ads-library-scraper) — see how event organizers in your niche advertise, and which creatives they keep running.
- [Telegram Channel Scraper](https://apify.com/datascoutlab/telegram-channels-scraper) — track how events get promoted in public communities.
- [Indeed Jobs Scraper](https://apify.com/datascoutlab/indeed-scraper) — find companies hiring in a city, another angle on local business activity.

# Actor input Schema

## `locations` (type: `array`):

Cities or countries to search. Any of these forms works and they can be mixed:

• `Berlin, Germany` — plain city and country
• `germany--berlin` — an Eventbrite location slug
• a full URL like `https://www.eventbrite.com/d/germany--berlin/music--events/`

Each location is searched separately, so three cities in one run means three independent result sets. Not needed when **Online events only** is switched on.

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

Narrow results to one Eventbrite category. Leave on `All categories` to get everything happening in the location.

## `keyword` (type: `string`):

Free-text search within the location — a topic, a brand or an artist. Leave empty to get everything in the chosen category.

## `dates` (type: `string`):

Which events to include by date. `Upcoming` covers everything from today onwards.

## `startDate` (type: `string`):

Optional exact range start, `YYYY-MM-DD`. Set both start and end to override the time frame above.

## `endDate` (type: `string`):

Optional exact range end, `YYYY-MM-DD`.

## `priceFilter` (type: `string`):

Keep only free or only paid events. Free events tend to be community-run; paid ones carry organizer revenue signals.

## `onlineOnly` (type: `boolean`):

Search online events instead of ones tied to a physical venue. Eventbrite indexes online events worldwide, so the location list above is ignored when this is on.

## `maxResultsPerLocation` (type: `integer`):

Upper bound per location. You are billed per event returned, so this is also your cost ceiling. Eventbrite exposes up to 10,000 events per search.

## `includeDescription` (type: `boolean`):

Add the event's full description text to each row. Useful for keyword analysis, but makes the dataset noticeably heavier.

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

Eventbrite rate-limits single IPs on larger runs. Datacenter proxies are enough here — residential ones are not required and only add cost.

## Actor input object example

```json
{
  "locations": [
    "New York, United States"
  ],
  "category": "all",
  "dates": "current_future",
  "priceFilter": "any",
  "onlineOnly": false,
  "maxResultsPerLocation": 200,
  "includeDescription": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every event found, with venue, pricing, organizer and demand signals in one flat row.

## `eventsCsv` (type: `string`):

The same rows as CSV in a readable column order — open in Excel or pull into Google Sheets with IMPORTDATA().

## `runSummary` (type: `string`):

How many events were collected per location and which requests failed, with the reason for each.

# 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 = {
    "locations": [
        "New York, United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutlab/eventbrite-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 = { "locations": ["New York, United States"] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutlab/eventbrite-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 '{
  "locations": [
    "New York, United States"
  ]
}' |
apify call datascoutlab/eventbrite-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Scraper — Events, Organizers & Demand Signals",
        "description": "Scrape Eventbrite events by city, category, keyword or date. Every row carries the venue with coordinates, ticket prices, and the organizer with follower count and social links - resolved without an extra request or an extra charge. Includes Eventbrite's own demand signals.",
        "version": "1.0",
        "x-build-id": "sdBkwVNhCVInzGfg9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutlab~eventbrite-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutlab-eventbrite-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/datascoutlab~eventbrite-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascoutlab-eventbrite-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/datascoutlab~eventbrite-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutlab-eventbrite-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": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities or countries to search. Any of these forms works and they can be mixed:\n\n• `Berlin, Germany` — plain city and country\n• `germany--berlin` — an Eventbrite location slug\n• a full URL like `https://www.eventbrite.com/d/germany--berlin/music--events/`\n\nEach location is searched separately, so three cities in one run means three independent result sets. Not needed when **Online events only** is switched on.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "all",
                            "103",
                            "101",
                            "110",
                            "113",
                            "105",
                            "104",
                            "108",
                            "107",
                            "102",
                            "109",
                            "111",
                            "114",
                            "115",
                            "116",
                            "112",
                            "106",
                            "117",
                            "118",
                            "119",
                            "120",
                            "199"
                        ],
                        "type": "string",
                        "description": "Narrow results to one Eventbrite category. Leave on `All categories` to get everything happening in the location.",
                        "default": "all"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text search within the location — a topic, a brand or an artist. Leave empty to get everything in the chosen category."
                    },
                    "dates": {
                        "title": "Time frame",
                        "enum": [
                            "current_future",
                            "today",
                            "tomorrow",
                            "this_week",
                            "this_weekend",
                            "next_week",
                            "this_month",
                            "next_month",
                            "any"
                        ],
                        "type": "string",
                        "description": "Which events to include by date. `Upcoming` covers everything from today onwards.",
                        "default": "current_future"
                    },
                    "startDate": {
                        "title": "Custom range — from",
                        "type": "string",
                        "description": "Optional exact range start, `YYYY-MM-DD`. Set both start and end to override the time frame above."
                    },
                    "endDate": {
                        "title": "Custom range — to",
                        "type": "string",
                        "description": "Optional exact range end, `YYYY-MM-DD`."
                    },
                    "priceFilter": {
                        "title": "Price",
                        "enum": [
                            "any",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Keep only free or only paid events. Free events tend to be community-run; paid ones carry organizer revenue signals.",
                        "default": "any"
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "Search online events instead of ones tied to a physical venue. Eventbrite indexes online events worldwide, so the location list above is ignored when this is on.",
                        "default": false
                    },
                    "maxResultsPerLocation": {
                        "title": "Max events per location",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper bound per location. You are billed per event returned, so this is also your cost ceiling. Eventbrite exposes up to 10,000 events per search.",
                        "default": 200
                    },
                    "includeDescription": {
                        "title": "Include full description",
                        "type": "boolean",
                        "description": "Add the event's full description text to each row. Useful for keyword analysis, but makes the dataset noticeably heavier.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Eventbrite rate-limits single IPs on larger runs. Datacenter proxies are enough here — residential ones are not required and only add cost.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
