# 10times Events Scraper (`maximedupre/10times-events-scraper`) Actor

Scrape public 10times events by search filters or URLs. Export event names, dates, locations, organizers, categories, attendance signals, source links, and scrape metadata.

- **URL**: https://apify.com/maximedupre/10times-events-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 scraped events

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

### 🔎 10times events scraper for trade show research

10times Events Scraper turns public [10times.com](https://10times.com/) event pages and event listings into a structured dataset. Search by topic and location, or paste 10times event, city, category, country, listing, or search URLs when you already know the pages you want to scrape.

Use this 10times events scraper when you need trade shows, conferences, workshops, exhibitions, and festival listings for event research, B2B sales planning, market mapping, sponsorship research, or calendar monitoring. Each saved row is one real public 10times event with source IDs, dates, location data, organizer details when available, categories, public attendance signals, source URLs, and scrape metadata.

For a small first run, keep the default New York technology search and `Event limit` set to `25`. When the output shape fits your workflow, raise the limit, paste more URLs, schedule repeat runs, or call the Actor through the Apify API.

### ✅ What this Actor does

- Searches public 10times event listings by query, location, country, industry category, event type, date range, and online-event filter.
- Scrapes direct 10times event, listing, city, country, category, and search URLs.
- Saves one dataset row per accepted 10times event.
- Extracts event names, source event IDs, edition IDs, URLs, event types, dates, descriptions, locations, organizers, categories, public stats, media links, and source metadata when available.
- Supports `excludeEditionIds` so recurring runs can skip event editions you already saved.
- Keeps source-access, retry, and proxy details internal. Users do not need a 10times account, cookies, password, or API key.
- Emits only real event rows. Blocked or empty source outcomes are reported in logs instead of fake placeholder rows.
- Charges only for saved event rows.

This Actor focuses on public 10times event data. It does not scrape private attendee lists, logged-in dashboards, exhibitor lead exports, registration pages, badge downloads, email-enrichment databases, or event sites outside 10times.

### 📦 Data you can extract

Each dataset item represents one public 10times event. Fields can include:

- `id`, `editionId`, `name`, `shortName`, `url`, and `type`
- `startDate`, `endDate`, `dateLabel`, and `status`
- `description`, `tags`, `pricing`, `website`, and `eventHost`
- `onlineEvent` and `hybrid`
- `location` with city, country, venue, address, coordinate, and source-location fields when available
- `organizer` with name, URL, website, and public organizer metrics when available
- `stats` with rating, rating count, followers, estimated visitors, estimated exhibitors, exhibitors, speakers, and reviews when available
- `categories`, `products`, `schedule`, and `media`
- `source` with source URL, source type, listing position, raw event ID, and raw edition ID
- `dataQuality` and `scrapedAt`

10times does not show every field for every event. Missing public values are returned as `null`, empty arrays, or partial data-quality notes instead of guessed data.

### 🎯 Common use cases

- Build trade show and conference calendars by market, city, or topic.
- Find B2B events for sales trips, sponsorship planning, partnerships, or field marketing.
- Compare event categories, locations, dates, and public attendance signals.
- Monitor 10times listings over time with scheduled Apify runs.
- Create event datasets for spreadsheets, CRMs, warehouses, dashboards, or API workflows.
- Keep source event URLs and edition IDs for repeat research and deduplication.

### ▶️ How to run it

1. Choose **Target**:
   - **Search events** to search 10times by topic and location.
   - **Scrape 10times URLs** to start from pages you already have.
2. For search runs, enter a `Search query`, `Location`, and optional filters such as `Industry category`, `Event type`, `Start date`, and `End date`.
3. For URL runs, paste one or more 10times event, listing, city, country, category, or search URLs.
4. Set `Event limit` to keep the first run small.
5. Run the Actor and export the dataset as JSON, CSV, Excel, XML, RSS, or through the Apify API.

Good first targets:

- `technology` in `New York, US`
- `healthcare` in `London, UK`
- `https://10times.com/newyork-us/technology`
- `https://10times.com/ces-las-vegas`

### ⚙️ Input options

| Field | What it does |
| --- | --- |
| `target` | Chooses search mode or URL mode. |
| `startUrls` | 10times event, listing, city, country, category, or search URLs for URL runs. |
| `query` | Searches event names and descriptions. |
| `location` | Free-text city, country, or coordinates such as `New York, US` or `40.7128,-74.0060`. |
| `country` | Country for broader generated searches when `location` is empty or country-level. |
| `category` | 10times industry category ID from the dropdown. |
| `categoryText` | Extra industry wording such as `SaaS`, `cybersecurity`, or `food manufacturing`. |
| `eventType` | Filters by all events, trade shows, conferences, workshops, exhibitions, or festivals. |
| `startDate` and `endDate` | Keep events inside a date range when source dates are available. |
| `onlineOnly` | Keeps online or virtual events only. |
| `sortBy` and `sortOrder` | Applies ranking to generated search and listing targets when supported by the source surface. |
| `radiusMiles` | Search radius when `location` is a coordinate pair. |
| `cityIds` | Advanced 10times city IDs when you already know exact source IDs. |
| `excludeEditionIds` | Edition IDs from previous runs that should be skipped. |
| `maxItems` | Maximum event rows to save across the run. |

### 🧪 Example input

```json
{
	"target": "search",
	"query": "technology",
	"location": "New York, US",
	"country": "US",
	"category": "156",
	"eventType": "all",
	"sortBy": "date",
	"sortOrder": "asc",
	"onlineOnly": false,
	"maxItems": 25
}
````

### 🧾 Example output

```json
{
	"id": 687457,
	"editionId": 4584166,
	"name": "Global Energy Transition",
	"url": "https://10times.com/e13z-krp0-sr02",
	"type": "Conference",
	"startDate": "2026-06-23",
	"endDate": "2026-06-24",
	"description": "Public event summary from 10times",
	"website": "https://example.com/event",
	"location": {
		"cityName": "New York",
		"countryName": null,
		"venueName": "New York",
		"venueAddress": null
	},
	"organizer": {
		"name": "Reuters News & Media Ltd",
		"url": "https://10times.com/company/reuters-news-"
	},
	"stats": {
		"rating": 4.7,
		"ratingCount": 3,
		"estimatedExhibitors": 119,
		"speakers": 10
	},
	"categories": [
		{
			"id": null,
			"name": "IT & Technology",
			"url": null
		}
	],
	"source": {
		"sourceType": "listing",
		"resultPosition": 1,
		"rawEventId": 687457,
		"rawEditionId": 4584166
	},
	"dataQuality": {
		"status": "complete",
		"missingFields": [],
		"detailPageFetched": true,
		"detailUnavailableReason": null
	},
	"scrapedAt": "2026-06-13T14:08:36.738Z"
}
```

The example is shortened for readability. The actual dataset can include more nested fields when 10times exposes them.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each accepted public event row saved to the dataset.

Current planned event prices:

| Apify plan | Price per 1,000 saved events |
| --- | ---: |
| Free | $1.80 |
| Bronze | $1.50 |
| Silver | $1.15 |
| Gold | $0.90 |
| Platinum | $0.90 |
| Diamond | $0.90 |

The Actor does not charge for empty runs, skipped duplicate edition IDs, invalid targets that do not produce event rows, or source outcomes that are reported only in logs.

### ⚠️ Limits and caveats

- Field availability depends on what public 10times pages show for each event.
- Some events have rich organizer, venue, and attendance data. Others expose only a name, URL, date, category, and location text.
- `excludeEditionIds` is useful for recurring runs, but it only skips editions whose IDs are available from the source.
- Broad searches can produce many matching events. Use `Event limit` for a bounded first run.
- This Actor does not provide private attendee data, exhibitor lead exports, registration actions, or contact enrichment outside public 10times/event/organizer pages.

### ❓ FAQ

#### 🔐 Do I need a 10times account?

No. The Actor collects public 10times event data and does not ask for 10times cookies, passwords, or API keys.

#### 🔗 Can I paste a direct event URL?

Yes. Choose **Scrape 10times URLs** and paste public 10times event URLs, listing URLs, city pages, country pages, category pages, or search pages.

#### 🧩 What happens if a field is missing?

The Actor leaves missing public values empty and adds data-quality notes for partial rows. It does not guess visitor counts, organizer details, venue addresses, or schedule data.

#### 📅 Can I schedule recurring event monitoring?

Yes. Apify lets you schedule runs. Save the `editionId` values from earlier datasets and pass them into `excludeEditionIds` to skip already collected editions when 10times exposes those IDs.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~10times-events-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Map Your Show Exhibitor Scraper ↗](https://apify.com/maximedupre/map-your-show-exhibitor-scraper) - collect exhibitor company data from public event directories.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - enrich event and sponsor account lists with public company profile data.
- [LinkedIn Company People Scraper ↗](https://apify.com/maximedupre/linkedin-company-people-scraper) - map visible people at known companies for recruiting or sales research.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - find public contact emails from websites you already plan to research.
- [Google Shopping Ads Scraper ↗](https://apify.com/maximedupre/google-shopping-ads-scraper) - monitor live paid Shopping ads for market and competitor research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `target` (type: `string`):

Choose whether this run searches 10times or starts from specific 10times URLs.

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

Paste 10times event, listing, city, country, category, or search URLs for URL runs.

## `query` (type: `string`):

Search event names and descriptions, such as technology, packaging, healthcare, or fintech.

## `location` (type: `string`):

Enter a city, country, or coordinates such as New York, US or 40.7128,-74.0060.

## `country` (type: `string`):

Choose a country for broad searches when Location is empty or country-level.

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

Choose a 10times industry category for generated searches.

## `categoryText` (type: `string`):

Add industry wording such as SaaS, dental, packaging, cybersecurity, or food manufacturing.

## `eventType` (type: `string`):

Choose the event type for generated searches.

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

Keep events starting on or after this date.

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

Keep events ending on or before this date.

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

Collect virtual and online events only.

## `sortBy` (type: `string`):

Set the order for generated search and listing targets.

## `sortOrder` (type: `string`):

Choose ascending or descending order for generated searches.

## `radiusMiles` (type: `integer`):

Search radius in miles when Location is a coordinate pair.

## `cityIds` (type: `array`):

Add known 10times city IDs when you already have exact source IDs.

## `excludeEditionIds` (type: `array`):

Add edition IDs from earlier runs to collect newer matching events.

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

Maximum number of events to save across the whole run.

## Actor input object example

```json
{
  "target": "search",
  "startUrls": [
    {
      "url": "https://10times.com/newyork-us/technology"
    }
  ],
  "query": "technology",
  "location": "New York, US",
  "country": "US",
  "category": "156",
  "categoryText": "",
  "eventType": "all",
  "onlineOnly": false,
  "sortBy": "date",
  "sortOrder": "asc",
  "radiusMiles": 50,
  "maxItems": 25
}
```

# Actor output Schema

## `results` (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://10times.com/newyork-us/technology"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/10times-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://10times.com/newyork-us/technology" }] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/10times-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://10times.com/newyork-us/technology"
    }
  ]
}' |
apify call maximedupre/10times-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "10times Events Scraper",
        "description": "Scrape public 10times events by search filters or URLs. Export event names, dates, locations, organizers, categories, attendance signals, source links, and scrape metadata.",
        "version": "0.0",
        "x-build-id": "XFXdDCfmNMarQnBSD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~10times-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-10times-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/maximedupre~10times-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-10times-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/maximedupre~10times-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-10times-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": {
                    "target": {
                        "title": "Target",
                        "enum": [
                            "search",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Choose whether this run searches 10times or starts from specific 10times URLs.",
                        "default": "search"
                    },
                    "startUrls": {
                        "title": "10times URLs",
                        "type": "array",
                        "description": "Paste 10times event, listing, city, country, category, or search URLs for URL runs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "A public 10times event, listing, city, country, category, or search URL."
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search event names and descriptions, such as technology, packaging, healthcare, or fintech.",
                        "default": "technology"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Enter a city, country, or coordinates such as New York, US or 40.7128,-74.0060.",
                        "default": "New York, US"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "WW",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "AU",
                            "CA",
                            "JP",
                            "IN",
                            "BR",
                            "MX",
                            "CN",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Choose a country for broad searches when Location is empty or country-level.",
                        "default": "US"
                    },
                    "category": {
                        "title": "Industry category",
                        "enum": [
                            "",
                            "3",
                            "5",
                            "7",
                            "13",
                            "16",
                            "19",
                            "27",
                            "30",
                            "34",
                            "37",
                            "50",
                            "53",
                            "55",
                            "61",
                            "63",
                            "80",
                            "106",
                            "107",
                            "108",
                            "113",
                            "125",
                            "128",
                            "146",
                            "150",
                            "156",
                            "158",
                            "159",
                            "160",
                            "161"
                        ],
                        "type": "string",
                        "description": "Choose a 10times industry category for generated searches.",
                        "default": "156"
                    },
                    "categoryText": {
                        "title": "Category text",
                        "type": "string",
                        "description": "Add industry wording such as SaaS, dental, packaging, cybersecurity, or food manufacturing.",
                        "default": ""
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "all",
                            "tradeshow",
                            "conference",
                            "workshop",
                            "exhibition",
                            "festival"
                        ],
                        "type": "string",
                        "description": "Choose the event type for generated searches.",
                        "default": "all"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Keep events starting on or after this date."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Keep events ending on or before this date."
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "Collect virtual and online events only.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort events by",
                        "enum": [
                            "date",
                            "score",
                            "name",
                            "followers",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Set the order for generated search and listing targets.",
                        "default": "date"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Choose ascending or descending order for generated searches.",
                        "default": "asc"
                    },
                    "radiusMiles": {
                        "title": "Radius",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Search radius in miles when Location is a coordinate pair.",
                        "default": 50
                    },
                    "cityIds": {
                        "title": "10times city IDs",
                        "type": "array",
                        "description": "Add known 10times city IDs when you already have exact source IDs.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "excludeEditionIds": {
                        "title": "Skip edition IDs",
                        "type": "array",
                        "description": "Add edition IDs from earlier runs to collect newer matching events.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxItems": {
                        "title": "Event limit",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of events to save across the whole run.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
